tarinai/js/achievements.js

"use strict";

(function initAchievementSystem(global) {
  // v7 uses a fresh namespace so tabs left open on older builds cannot write
  // stale full-state envelopes into the current persistence layer.
  const STORAGE_KEY = "tarinai_achievements_v7";
  const STORAGE_BACKUP_KEY = "tarinai_achievements_backup_v7";
  const STORAGE_SESSION_KEY = "tarinai_achievements_session_v7";
  const PREVIOUS_STORAGE_KEY = "tarinai_achievements_v6";
  const PREVIOUS_STORAGE_BACKUP_KEY = "tarinai_achievements_backup_v6";
  const PREVIOUS_STORAGE_SESSION_KEY = "tarinai_achievements_session_v6";
  const OLDER_STORAGE_KEY = "tarinai_achievements_v5";
  const OLDER_STORAGE_BACKUP_KEY = "tarinai_achievements_backup_v5";
  const OLDER_STORAGE_SESSION_KEY = "tarinai_achievements_session_v5";
  const LEGACY_STORAGE_KEY = "tarinai_achievements_v4";
  const LEGACY_STORAGE_BACKUP_KEY = "tarinai_achievements_backup_v4";
  const LEGACY_STORAGE_SESSION_KEY = "tarinai_achievements_session_v4";
  const ANCIENT_STORAGE_KEY = "tarinai_achievements_v2";
  const ANCIENT_STORAGE_BACKUP_KEY = "tarinai_achievements_backup_v3";
  const ANCIENT_STORAGE_SESSION_KEY = "tarinai_achievements_session_v3";
  const PERSISTENCE_FORMAT = "tarinai-achievements-envelope-v1";
  const PERSISTENCE_DB_NAME = "tarinai_achievements_durable_v5";
  const PREVIOUS_PERSISTENCE_DB_NAME = "tarinai_achievements_durable_v4";
  const OLDER_PERSISTENCE_DB_NAME = "tarinai_achievements_durable_v3";
  const LEGACY_PERSISTENCE_DB_NAME = "tarinai_achievements_durable_v2";
  const ANCIENT_PERSISTENCE_DB_NAME = "tarinai_achievements_durable_v1";
  const PERSISTENCE_DB_STORE = "records";
  const PERSISTENCE_DB_KEY = "achievement-state";
  const PERSISTENCE_CHANNEL_NAME = "tarinai-achievements-persistence-v5";
  const PREHYDRATION_JOURNAL_PREFIX = "tarinai_achievements_pre_hydration_v7_";
  const PREHYDRATION_JOURNAL_FORMAT = "tarinai-achievements-pre-hydration-v1";
  const PREHYDRATION_JOURNAL_DB_PREFIX = "pre-hydration-journal:";
  const PLAYER_KEY = "tarinai_achievement_player_v1";
  const PLAYER_SECRET_KEY = "tarinai_achievement_player_secret_v1";
  const LEGACY_PLAYER_KEY = "tarinai_achievement_legacy_player_v4";
  const API_URL = String(global.TARINAI_ACHIEVEMENT_API || "achievement_api.php");
  const GAME_VERSION = String(global.TARINAI_VERSION || "39.18.18");
  const DEBUG_MODE = ["1", "true"].includes(new URLSearchParams(global.location?.search || "").get("debug"));
  const PLAYER_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
  const LEGACY_PLAYER_ID_PATTERN = /^[A-Za-z0-9_-]{22}$/;
  const PLAYER_SECRET_PATTERN = /^[0-9a-f]{64}$/i;
  const ABSOLUTE_ZERO_C = -273.15;
  const CONTINUOUS_PLAY_TARGET_MS = 60 * 60 * 1000;
  const CONTINUOUS_PLAY_24H_TARGET_MS = 24 * 60 * 60 * 1000;
  const HELD_TARGET_MS = 30 * 1000;
  const ACHIEVEMENT_CATALOG = global.TARINAI_ACHIEVEMENT_CATALOG;
  if (!ACHIEVEMENT_CATALOG || !Array.isArray(ACHIEVEMENT_CATALOG.definitions) || !Array.isArray(ACHIEVEMENT_CATALOG.categories)) {
    throw new Error("achievement catalog unavailable");
  }
  const COMPLETIONIST_ID = String(ACHIEVEMENT_CATALOG.completionistId || "true_tarinai_observer");
  const ACHIEVEMENT_CATALOG_REVISION = String(ACHIEVEMENT_CATALOG.revision || "unknown");
  const GENERATION_TARGET = 10;
  const DAY_MS = 24 * 60 * 60 * 1000;
  const SYNC_DEBOUNCE_MS = 450;
  const FULL_SYNC_INTERVAL_MS = 5 * 60 * 1000;
  const SYNC_PROTOCOL_VERSION = 5;
  const SPELL_STATE_VERSION = 11; // v11 stores additive counters only in the canonical ledger.
  const MEDICINE_LEDGER_TYPES = Object.freeze([...(ACHIEVEMENT_CATALOG.medicineLedgerTypes || [])]);
  const LINK_PROGRESS_TYPES = Object.freeze([...(ACHIEVEMENT_CATALOG.linkProgressTypes || [])]);
  const ADDITIVE_PROGRESS_CAPS = Object.freeze({ ...(ACHIEVEMENT_CATALOG.additiveProgressCaps || {}) });
  const ADDITIVE_PROGRESS_KEYS = Object.freeze(Object.keys(ADDITIVE_PROGRESS_CAPS));
  const CHAOS_FIGHT_TARGET = ADDITIVE_PROGRESS_CAPS.fightMochiFightCount;
  const SNIPER_SHOT_TARGET = ADDITIVE_PROGRESS_CAPS.shotCount;
  const FERTILITY_BIRTH_TARGET = ADDITIVE_PROGRESS_CAPS.loveMochiBirthCount;
  const DAILY_PLAY_TARGET = 7;
  const WIRE_SHOCK_TARGET = 7;
  const ROBOT_CLEAN_TARGET = ADDITIVE_PROGRESS_CAPS.robotCleanCount;
  const ROBOT_ALL_TARGET_MASK = 0x7f;
  const OBSERVER_GAME_DAYS = 3;
  const STRENGTH_IN_NUMBERS_TARGET = 100;
  const ELITE_FEW_MAX_POPULATION = 25;
  const ELITE_FEW_TARGET_DAYS = 5;
  const STATISTICIAN_TARGET = ADDITIVE_PROGRESS_CAPS.statsButtonPressCount;
  const LIVELY_MAKING_TARGET = ADDITIVE_PROGRESS_CAPS.manualTarinaiAddedCount;
  const MEMENTO_MORI_TARGET = ADDITIVE_PROGRESS_CAPS.totalDeathCount;
  const MAD_SCIENTIST_TARGET = Number(ACHIEVEMENT_CATALOG.definitions.find(def => def.id === "mad_scientist")?.progress?.target || 10);
  const FULL_SEASON_CYCLE_DAYS = 20;
  const DEFINITIONS = Object.freeze(ACHIEVEMENT_CATALOG.definitions.map(definition => Object.freeze({ ...definition })));
  const PRE_UNLOCK_DESCRIPTION_IDS = new Set(DEFINITIONS.filter(definition => definition.showLockedDescription).map(definition => definition.id));
  const ACHIEVEMENT_CATEGORIES = Object.freeze(ACHIEVEMENT_CATALOG.categories.map(category => Object.freeze({
    id: String(category.id || ""),
    title: String(category.title || ""),
    ids: Object.freeze(DEFINITIONS.filter(definition => definition.category === category.id).map(definition => definition.id)),
  })));
  const definitionById = new Map(DEFINITIONS.map(def => [def.id, def]));
  const CATEGORY_DEFINITIONS = new Map(ACHIEVEMENT_CATEGORIES.map(category => [
    category.id,
    Object.freeze(category.ids.map(id => definitionById.get(id)).filter(Boolean)),
  ]));

  const dom = {
    button: document.getElementById("achievementsBtn"),
    buttonCount: document.getElementById("achievementButtonCount"),
    dialog: document.getElementById("achievementsDialog"),
    dialogCount: document.getElementById("achievementDialogCount"),
    closeButton: document.getElementById("achievementsCloseBtn"),
    closeIconButton: document.getElementById("achievementsCloseIconBtn"),
    refreshButton: document.getElementById("achievementRefreshBtn"),
    resetButton: document.getElementById("achievementResetBtn"),
    unlockAllButton: document.getElementById("achievementUnlockAllBtn"),
    list: document.getElementById("achievementList"),
    sharedStatus: document.getElementById("achievementSharedStatus"),
    toast: document.getElementById("achievementToast"),
    toastTitle: document.getElementById("achievementToastTitle"),
    toastCondition: document.getElementById("achievementToastCondition"),
    pauseButton: document.getElementById("pauseBtn"),
  };

  function createPersistenceActorId() {
    if (global.crypto?.randomUUID) return global.crypto.randomUUID();
    return `tab-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}-${Math.random().toString(36).slice(2)}`;
  }

  const persistenceActorId = createPersistenceActorId();
  let persistenceGeneration = 0;
  let persistenceRevision = 0;
  let persistenceHydrated = false;
  let persistenceDirty = false;
  let durableWriteQueue = Promise.resolve();
  let persistenceReadyPromise = Promise.resolve();
  let persistenceChannel = null;
  const initialPersistence = loadStateRecord();
  const initialPersistenceBaseline = normalizeState(initialPersistence.state);
  let state = initialPersistence.state;
  persistenceGeneration = initialPersistence.generation;
  persistenceRevision = initialPersistence.revision;
  let shared = { connected: false, loading: false, totalPlayers: 0, achievements: {}, statisticsTrust: "client-reported" };
  let requestSerial = 0;
  let runtimeByWorld = new WeakMap();
  let dangerFightDeathsByWorld = new WeakMap();
  let wireShockTrackers = new WeakMap();
  let syncQueue = Promise.resolve();
  let toastQueue = [];
  let toastActive = false;
  let emptyClickTimes = [];
  let groundChangeTimes = [];
  let continuousPlayAccumulatedMs = 0;
  let continuousPlayLastHeartbeatAt = Date.now();
  let continuousPlayActive = !document.hidden;
  let lastListSignature = "";
  let scheduledSyncTimer = 0;
  let scheduledProgressSaveTimer = 0;
  let progressMutationRevision = 0;
  let progressSyncedRevision = 0;

  function blankProgressLedger() {
    return {
      base: Object.fromEntries(ADDITIVE_PROGRESS_KEYS.map(key => [key, 0])),
      shards: Object.fromEntries(ADDITIVE_PROGRESS_KEYS.map(key => [key, {}])),
    };
  }

  function blankState() {
    return {
      unlocked: {},
      pending: [],
      resetPending: false,
      debugUnlocked: [],
      serverIdentity: null,
      progress: { linkTypes: [], signalActivated: false, medicineTypes: [], dailyPlayStreak: 0, dailyPlayLastDay: 0, mysteryDrugTarinaiIds: [] },
      _progressLedger: blankProgressLedger(),
    };
  }

  function ledgerCounterValue(ledgerInput, key) {
    if (!Object.prototype.hasOwnProperty.call(ADDITIVE_PROGRESS_CAPS, key)) return 0;
    const cap = ADDITIVE_PROGRESS_CAPS[key];
    const ledger = ledgerInput && typeof ledgerInput === "object" ? ledgerInput : {};
    const base = Math.min(cap, Math.max(0, Math.floor(Number(ledger.base?.[key] || 0) || 0)));
    const shards = ledger.shards?.[key] && typeof ledger.shards[key] === "object" ? ledger.shards[key] : {};
    return Math.min(cap, base + Object.values(shards).reduce((sum, value) => sum + Math.max(0, Math.floor(Number(value || 0) || 0)), 0));
  }

  function sanitizeProgressLedger(parsed, legacyProgress = {}) {
    const source = parsed?._progressLedger && typeof parsed._progressLedger === "object" ? parsed._progressLedger : {};
    const baseSource = source.base && typeof source.base === "object" ? source.base : {};
    const shardsSource = source.shards && typeof source.shards === "object" ? source.shards : {};
    const ledger = blankProgressLedger();
    for (const key of ADDITIVE_PROGRESS_KEYS) {
      const cap = ADDITIVE_PROGRESS_CAPS[key];
      let base = Math.min(cap, Math.max(0, Math.floor(Number(baseSource[key] || 0) || 0)));
      const shards = {};
      const rawShards = shardsSource[key] && typeof shardsSource[key] === "object" ? shardsSource[key] : {};
      for (const [actorId, rawValue] of Object.entries(rawShards)) {
        const id = String(actorId || "").slice(0, 160);
        const value = Math.min(cap, Math.max(0, Math.floor(Number(rawValue || 0) || 0)));
        if (id && value > 0) shards[id] = value;
      }
      let total = Math.min(cap, base + Object.values(shards).reduce((sum, value) => sum + value, 0));
      const legacyFloor = Math.min(cap, Math.max(0, Math.floor(Number(legacyProgress[key] || 0) || 0)));
      if (legacyFloor > total) {
        base = Math.min(cap, base + (legacyFloor - total));
        total = legacyFloor;
      }
      if (total >= cap) {
        base = cap;
        for (const actorId of Object.keys(shards)) delete shards[actorId];
      }
      ledger.base[key] = base;
      ledger.shards[key] = shards;
    }
    return ledger;
  }

  function normalizeServerIdentity(value) {
    if (!value || typeof value !== "object") return null;
    const id = String(value.playerId || "").toLowerCase();
    const secret = String(value.playerSecret || "").toLowerCase();
    if (!PLAYER_ID_PATTERN.test(id) || !PLAYER_SECRET_PATTERN.test(secret)) return null;
    return { playerId: id, playerSecret: secret };
  }

  function normalizeState(parsed) {
    if (!parsed || typeof parsed !== "object") return blankState();
    const unlockedSource = parsed.unlocked && typeof parsed.unlocked === "object" ? parsed.unlocked : {};
    const unlocked = {};
    for (const [id, timestamp] of Object.entries(unlockedSource)) {
      if (definitionById.has(id) && Number(timestamp) > 0) unlocked[id] = Number(timestamp);
    }
    const debugUnlockedSource = Array.isArray(parsed.debugUnlocked) ? parsed.debugUnlocked : [];
    const debugUnlocked = [...new Set(debugUnlockedSource.filter(id => definitionById.has(id)))];
    if (!DEBUG_MODE) {
      for (const id of debugUnlocked) delete unlocked[id];
    }
    // v6 and older persisted a redundant synced list. It is read once only to
    // avoid re-queuing already acknowledged legacy unlocks, then discarded.
    const legacySynced = new Set((Array.isArray(parsed.synced) ? parsed.synced : []).filter(id => definitionById.has(id)));
    const pendingSource = Array.isArray(parsed.pending) ? parsed.pending : [];
    const pending = pendingSource.filter(id => definitionById.has(id) && unlocked[id] && !debugUnlocked.includes(id) && !legacySynced.has(id));
    const progressSource = parsed.progress && typeof parsed.progress === "object" ? parsed.progress : {};
    const progress = {
      linkTypes: [...new Set((Array.isArray(progressSource.linkTypes) ? progressSource.linkTypes : []).filter(type => LINK_PROGRESS_TYPES.includes(type)))],
      signalActivated: Boolean(progressSource.signalActivated),
      medicineTypes: [...new Set((Array.isArray(progressSource.medicineTypes) ? progressSource.medicineTypes : []).filter(type => MEDICINE_LEDGER_TYPES.includes(type)))],
      dailyPlayStreak: Math.min(DAILY_PLAY_TARGET, Math.max(0, Math.floor(Number(progressSource.dailyPlayStreak || 0) || 0))),
      dailyPlayLastDay: Math.max(0, Math.floor(Number(progressSource.dailyPlayLastDay || 0) || 0)),
      mysteryDrugTarinaiIds: [...new Set((Array.isArray(progressSource.mysteryDrugTarinaiIds) ? progressSource.mysteryDrugTarinaiIds : []).map(id => String(id || "")).filter(Boolean))].slice(0, MAD_SCIENTIST_TARGET),
    };
    const progressLedger = sanitizeProgressLedger(parsed, progressSource);
    const missingCompletionRequirement = DEFINITIONS.some(definition => definition.id !== COMPLETIONIST_ID && !unlocked[definition.id]);
    if (unlocked[COMPLETIONIST_ID] && missingCompletionRequirement) {
      delete unlocked[COMPLETIONIST_ID];
      const pendingIndex = pending.indexOf(COMPLETIONIST_ID);
      if (pendingIndex >= 0) pending.splice(pendingIndex, 1);
    }
    return { unlocked, pending: [...new Set(pending)], resetPending: Boolean(parsed.resetPending), debugUnlocked: DEBUG_MODE ? debugUnlocked : [], serverIdentity: normalizeServerIdentity(parsed.serverIdentity), progress, _progressLedger: progressLedger };
  }

  function decodePersistenceEnvelope(raw) {
    try {
      const parsed = typeof raw === "string" ? JSON.parse(raw) : raw;
      if (!parsed || typeof parsed !== "object") return null;
      if (parsed.format === PERSISTENCE_FORMAT && parsed.state && typeof parsed.state === "object") {
        return {
          generation: Math.max(0, Math.floor(Number(parsed.generation || 0) || 0)),
          revision: Math.max(0, Math.floor(Number(parsed.revision || 0) || 0)),
          updatedAt: Math.max(0, Number(parsed.updatedAt || 0) || 0),
          migrationComplete: Boolean(parsed.migrationComplete),
          state: normalizeState(parsed.state),
        };
      }
      return { generation: 0, revision: 0, updatedAt: 0, migrationComplete: false, state: normalizeState(parsed) };
    } catch (_) {
      return null;
    }
  }

  function mergeStateData(targetInput, sourceInput) {
    const target = normalizeState(targetInput);
    const source = normalizeState(sourceInput);
    for (const [id, timestamp] of Object.entries(source.unlocked)) {
      const current = Number(target.unlocked[id] || 0) || 0;
      target.unlocked[id] = current > 0 ? Math.min(current, timestamp) : timestamp;
    }
    target.pending = [...new Set([...target.pending, ...source.pending])]
      .filter(id => definitionById.has(id) && target.unlocked[id] && !target.debugUnlocked.includes(id));
    if (DEBUG_MODE) target.debugUnlocked = [...new Set([...target.debugUnlocked, ...source.debugUnlocked])];
    if (!target.serverIdentity && source.serverIdentity) target.serverIdentity = { ...source.serverIdentity };
    for (const key of ADDITIVE_PROGRESS_KEYS) {
      target._progressLedger.base[key] = Math.max(
        Number(target._progressLedger.base[key] || 0) || 0,
        Number(source._progressLedger.base[key] || 0) || 0,
      );
      const targetShards = target._progressLedger.shards[key] || (target._progressLedger.shards[key] = {});
      const sourceShards = source._progressLedger.shards[key] || {};
      for (const [actorId, value] of Object.entries(sourceShards)) {
        targetShards[actorId] = Math.max(Number(targetShards[actorId] || 0) || 0, Number(value || 0) || 0);
      }
    }
    // Daily streak and its last-day marker are one logical record. Merging the
    // two numbers independently can pair an old high streak with a new date.
    const targetDay = Number(target.progress.dailyPlayLastDay || 0) || 0;
    const sourceDay = Number(source.progress.dailyPlayLastDay || 0) || 0;
    if (sourceDay > targetDay) {
      target.progress.dailyPlayLastDay = sourceDay;
      target.progress.dailyPlayStreak = Number(source.progress.dailyPlayStreak || 0) || 0;
    } else if (sourceDay === targetDay) {
      target.progress.dailyPlayStreak = Math.max(Number(target.progress.dailyPlayStreak || 0) || 0, Number(source.progress.dailyPlayStreak || 0) || 0);
    }
    target.progress.signalActivated = Boolean(target.progress.signalActivated || source.progress.signalActivated);
    target.progress.linkTypes = [...new Set([...(target.progress.linkTypes || []), ...(source.progress.linkTypes || [])])];
    target.progress.medicineTypes = [...new Set([...(target.progress.medicineTypes || []), ...(source.progress.medicineTypes || [])])];
    target.progress.mysteryDrugTarinaiIds = [...new Set([...(target.progress.mysteryDrugTarinaiIds || []), ...(source.progress.mysteryDrugTarinaiIds || [])])].slice(0, MAD_SCIENTIST_TARGET);
    return normalizeState(target);
  }

  function growOnlyStateDelta(baseInput, currentInput) {
    const base = normalizeState(baseInput);
    const current = normalizeState(currentInput);
    const delta = blankState();
    for (const [id, timestamp] of Object.entries(current.unlocked)) {
      const previous = Number(base.unlocked[id] || 0) || 0;
      if (!previous || timestamp < previous) delta.unlocked[id] = timestamp;
    }
    delta.pending = current.pending.filter(id => delta.unlocked[id]);
    if (DEBUG_MODE) delta.debugUnlocked = current.debugUnlocked.filter(id => !base.debugUnlocked.includes(id));
    if (current.serverIdentity && (!base.serverIdentity || current.serverIdentity.playerId !== base.serverIdentity.playerId || current.serverIdentity.playerSecret !== base.serverIdentity.playerSecret)) {
      delta.serverIdentity = { ...current.serverIdentity };
    }
    for (const key of ADDITIVE_PROGRESS_KEYS) {
      const currentBase = Number(current._progressLedger.base[key] || 0) || 0;
      const baselineBase = Number(base._progressLedger.base[key] || 0) || 0;
      if (currentBase > baselineBase) delta._progressLedger.base[key] = currentBase;
      const currentShards = current._progressLedger.shards[key] || {};
      const baselineShards = base._progressLedger.shards[key] || {};
      const deltaShards = delta._progressLedger.shards[key]
        || (delta._progressLedger.shards[key] = {});
      for (const [actorId, value] of Object.entries(currentShards)) {
        if ((Number(value) || 0) > (Number(baselineShards[actorId]) || 0)) {
          deltaShards[actorId] = Number(value) || 0;
        }
      }
    }
    const currentDay = Number(current.progress.dailyPlayLastDay || 0) || 0;
    const baseDay = Number(base.progress.dailyPlayLastDay || 0) || 0;
    const currentStreak = Number(current.progress.dailyPlayStreak || 0) || 0;
    const baseStreak = Number(base.progress.dailyPlayStreak || 0) || 0;
    if (currentDay !== baseDay) {
      delta.progress.dailyPlayLastDay = currentDay;
      delta.progress.dailyPlayStreak = currentStreak;
    } else if (currentStreak > baseStreak) {
      delta.progress.dailyPlayStreak = currentStreak;
    }
    delta.progress.signalActivated = Boolean(current.progress.signalActivated && !base.progress.signalActivated);
    delta.progress.linkTypes = current.progress.linkTypes.filter(value => !base.progress.linkTypes.includes(value));
    delta.progress.medicineTypes = current.progress.medicineTypes.filter(value => !base.progress.medicineTypes.includes(value));
    delta.progress.mysteryDrugTarinaiIds = current.progress.mysteryDrugTarinaiIds.filter(value => !base.progress.mysteryDrugTarinaiIds.includes(value));
    return normalizeState(delta);
  }

  function readStorageCandidate(storage, key) {
    try { return decodePersistenceEnvelope(storage?.getItem?.(key) || null); }
    catch (_) { return null; }
  }

  function webStorageCandidates() {
    return [
      readStorageCandidate(global.localStorage, STORAGE_KEY),
      readStorageCandidate(global.localStorage, STORAGE_BACKUP_KEY),
      readStorageCandidate(global.sessionStorage, STORAGE_SESSION_KEY),
    ].filter(Boolean);
  }

  function legacyWebStorageCandidates() {
    return [
      readStorageCandidate(global.localStorage, PREVIOUS_STORAGE_KEY),
      readStorageCandidate(global.localStorage, PREVIOUS_STORAGE_BACKUP_KEY),
      readStorageCandidate(global.sessionStorage, PREVIOUS_STORAGE_SESSION_KEY),
      readStorageCandidate(global.localStorage, OLDER_STORAGE_KEY),
      readStorageCandidate(global.localStorage, OLDER_STORAGE_BACKUP_KEY),
      readStorageCandidate(global.sessionStorage, OLDER_STORAGE_SESSION_KEY),
      readStorageCandidate(global.localStorage, LEGACY_STORAGE_KEY),
      readStorageCandidate(global.localStorage, LEGACY_STORAGE_BACKUP_KEY),
      readStorageCandidate(global.sessionStorage, LEGACY_STORAGE_SESSION_KEY),
      readStorageCandidate(global.localStorage, ANCIENT_STORAGE_KEY),
      readStorageCandidate(global.localStorage, ANCIENT_STORAGE_BACKUP_KEY),
      readStorageCandidate(global.sessionStorage, ANCIENT_STORAGE_SESSION_KEY),
    ].filter(Boolean);
  }

  function decodePreHydrationJournal(raw) {
    try {
      const parsed = typeof raw === "string" ? JSON.parse(raw) : raw;
      if (!parsed || parsed.format !== PREHYDRATION_JOURNAL_FORMAT || !parsed.delta || typeof parsed.delta !== "object") return null;
      return {
        format: PREHYDRATION_JOURNAL_FORMAT,
        actorId: String(parsed.actorId || "").slice(0, 160),
        baseGeneration: Math.max(0, Math.floor(Number(parsed.baseGeneration || 0) || 0)),
        updatedAt: Math.max(0, Number(parsed.updatedAt || 0) || 0),
        delta: normalizeState(parsed.delta),
      };
    } catch (_) {
      return null;
    }
  }

  function storageJournalCandidates(storage) {
    const journals = [];
    try {
      const length = Math.max(0, Number(storage?.length || 0) || 0);
      for (let index = 0; index < length; index += 1) {
        const key = String(storage?.key?.(index) || "");
        if (!key.startsWith(PREHYDRATION_JOURNAL_PREFIX)) continue;
        const journal = decodePreHydrationJournal(storage?.getItem?.(key));
        if (journal) journals.push(journal);
      }
    } catch (_) {}
    return journals;
  }

  function webStorageJournals() {
    return [...storageJournalCandidates(global.localStorage), ...storageJournalCandidates(global.sessionStorage)];
  }

  function currentPreHydrationJournal() {
    return {
      format: PREHYDRATION_JOURNAL_FORMAT,
      actorId: persistenceActorId,
      baseGeneration: persistenceGeneration,
      updatedAt: Date.now(),
      delta: growOnlyStateDelta(initialPersistenceBaseline, state),
    };
  }

  function writePreHydrationJournalToWebStorage(journalInput) {
    const journal = decodePreHydrationJournal(journalInput);
    if (!journal) return false;
    let serialized = "";
    try { serialized = JSON.stringify(journal); } catch (_) { return false; }
    const key = `${PREHYDRATION_JOURNAL_PREFIX}${persistenceActorId}`;
    let stored = false;
    try { global.localStorage?.setItem?.(key, serialized); stored = true; } catch (_) {}
    try { global.sessionStorage?.setItem?.(key, serialized); stored = true; } catch (_) {}
    return stored;
  }

  function removeWebStorageJournals(maxGeneration = persistenceGeneration) {
    for (const storage of [global.localStorage, global.sessionStorage]) {
      try {
        const keys = [];
        const length = Math.max(0, Number(storage?.length || 0) || 0);
        for (let index = 0; index < length; index += 1) {
          const key = String(storage?.key?.(index) || "");
          if (key.startsWith(PREHYDRATION_JOURNAL_PREFIX)) keys.push(key);
        }
        for (const key of keys) {
          const journal = decodePreHydrationJournal(storage?.getItem?.(key));
          if (!journal || journal.baseGeneration <= maxGeneration) storage?.removeItem?.(key);
        }
      } catch (_) {}
    }
  }

  function persistenceStateSignature(generation, stateInput) {
    try { return `${Math.max(0, Number(generation) || 0)}:${JSON.stringify(normalizeState(stateInput))}`; }
    catch (_) { return `${Math.max(0, Number(generation) || 0)}:`; }
  }

  function normalizePersistenceCandidate(candidate) {
    if (candidate && typeof candidate === "object" && candidate.state && typeof candidate.state === "object" && Number.isFinite(Number(candidate.generation))) {
      return {
        generation: Math.max(0, Math.floor(Number(candidate.generation || 0) || 0)),
        revision: Math.max(0, Math.floor(Number(candidate.revision || 0) || 0)),
        updatedAt: Math.max(0, Number(candidate.updatedAt || 0) || 0),
        migrationComplete: Boolean(candidate.migrationComplete),
        state: normalizeState(candidate.state),
      };
    }
    return decodePersistenceEnvelope(candidate);
  }

  function mergePersistenceEnvelopes(candidatesInput, options = {}) {
    const candidates = (Array.isArray(candidatesInput) ? candidatesInput : [])
      .map(candidate => normalizePersistenceCandidate(candidate))
      .filter(Boolean);
    if (!candidates.length) {
      return {
        format: PERSISTENCE_FORMAT,
        generation: 0,
        revision: options.incrementRevision ? 1 : 0,
        updatedAt: Date.now(),
        migrationComplete: false,
        state: blankState(),
      };
    }
    const generation = Math.max(...candidates.map(candidate => candidate.generation));
    const active = candidates
      .filter(candidate => candidate.generation === generation)
      .sort((a, b) => (a.revision - b.revision) || (a.updatedAt - b.updatedAt));
    let merged = blankState();
    for (const candidate of active) merged = mergeStateData(merged, candidate.state);
    const latest = active[active.length - 1];
    merged.resetPending = Boolean(latest?.state?.resetPending);
    const latestIdentity = [...active].reverse().map(candidate => normalizeServerIdentity(candidate.state?.serverIdentity)).find(Boolean);
    if (latestIdentity) merged.serverIdentity = { ...latestIdentity };
    const maxRevision = Math.max(0, ...active.map(candidate => candidate.revision));
    return {
      format: PERSISTENCE_FORMAT,
      generation,
      revision: maxRevision + (options.incrementRevision ? 1 : 0),
      updatedAt: Date.now(),
      migrationComplete: active.some(candidate => candidate.migrationComplete),
      state: normalizeState(merged),
    };
  }

  function loadStateRecord() {
    const currentCandidates = webStorageCandidates();
    const currentGeneration = currentCandidates.length
      ? Math.max(...currentCandidates.map(candidate => candidate.generation))
      : 0;
    // v6 is written only by this build. Import older namespaces once, before a
    // completed v6 envelope exists. This still repairs the v39.17.7 failure
    // where an empty v5 envelope hid v4/v2 data, without reading old namespaces
    // forever and allowing an old open tab to contaminate current storage.
    const migrationComplete = currentCandidates.some(candidate => candidate.migrationComplete);
    const legacyCandidates = currentGeneration === 0 && !migrationComplete ? legacyWebStorageCandidates() : [];
    const candidates = [...currentCandidates, ...legacyCandidates];
    const source = currentCandidates.length && legacyCandidates.length
      ? "mixed"
      : (currentCandidates.length ? "current" : (legacyCandidates.length ? "legacy" : "empty"));
    const merged = mergePersistenceEnvelopes(candidates);
    return {
      generation: merged.generation,
      revision: merged.revision,
      updatedAt: merged.updatedAt,
      migrationComplete: merged.migrationComplete,
      state: merged.state,
      source,
    };
  }

  function persistenceEnvelope() {
    return {
      format: PERSISTENCE_FORMAT,
      generation: persistenceGeneration,
      revision: persistenceRevision,
      updatedAt: Date.now(),
      migrationComplete: true,
      state: normalizeState(state),
    };
  }

  function adoptPersistenceEnvelope(envelopeInput) {
    const envelope = normalizePersistenceCandidate(envelopeInput);
    if (!envelope || envelope.generation < persistenceGeneration) return false;
    const before = persistenceStateSignature(persistenceGeneration, state);
    if (envelope.generation > persistenceGeneration) {
      persistenceGeneration = envelope.generation;
      persistenceRevision = envelope.revision;
      state = normalizeState(envelope.state);
    } else {
      state = mergeStateData(state, envelope.state);
      if (envelope.revision >= persistenceRevision) {
        state.resetPending = Boolean(envelope.state.resetPending);
        const newerIdentity = normalizeServerIdentity(envelope.state.serverIdentity);
        if (newerIdentity) state.serverIdentity = { ...newerIdentity };
      }
      persistenceRevision = Math.max(persistenceRevision, envelope.revision);
    }
    return before !== persistenceStateSignature(persistenceGeneration, state);
  }

  function writeEnvelopeToWebStorage(envelopeInput) {
    const envelope = normalizePersistenceCandidate(envelopeInput);
    if (!envelope) return false;
    let serialized = "";
    try {
      serialized = JSON.stringify({
        format: PERSISTENCE_FORMAT,
        generation: envelope.generation,
        revision: envelope.revision,
        updatedAt: envelope.updatedAt || Date.now(),
        migrationComplete: Boolean(envelope.migrationComplete),
        state: normalizeState(envelope.state),
      });
    } catch (_) {
      return false;
    }
    let stored = false;
    try { global.localStorage?.setItem?.(STORAGE_BACKUP_KEY, serialized); stored = true; } catch (_) {}
    try { global.localStorage?.setItem?.(STORAGE_KEY, serialized); stored = true; } catch (_) {}
    try { global.sessionStorage?.setItem?.(STORAGE_SESSION_KEY, serialized); stored = true; } catch (_) {}
    return stored;
  }

  function broadcastPersistenceEnvelope(envelopeInput) {
    const envelope = normalizePersistenceCandidate(envelopeInput);
    if (!envelope) return;
    try { persistenceChannel?.postMessage?.(envelope); } catch (_) {}
  }

  function openPersistenceDatabase(databaseName = PERSISTENCE_DB_NAME) {
    return new Promise((resolve, reject) => {
      if (!global.indexedDB?.open) return reject(new Error("indexeddb unavailable"));
      let request;
      try { request = global.indexedDB.open(databaseName, 1); }
      catch (error) { reject(error); return; }
      request.onupgradeneeded = () => {
        const db = request.result;
        if (!db.objectStoreNames.contains(PERSISTENCE_DB_STORE)) db.createObjectStore(PERSISTENCE_DB_STORE);
      };
      request.onsuccess = () => resolve(request.result);
      request.onerror = () => reject(request.error || new Error("indexeddb open failed"));
      request.onblocked = () => reject(new Error("indexeddb blocked"));
    });
  }

  async function readDurableEnvelope(databaseName = PERSISTENCE_DB_NAME) {
    let db = null;
    try {
      db = await openPersistenceDatabase(databaseName);
      return await new Promise((resolve, reject) => {
        const tx = db.transaction(PERSISTENCE_DB_STORE, "readonly");
        const request = tx.objectStore(PERSISTENCE_DB_STORE).get(PERSISTENCE_DB_KEY);
        request.onsuccess = () => resolve(decodePersistenceEnvelope(request.result));
        request.onerror = () => reject(request.error || new Error("indexeddb read failed"));
        tx.onabort = () => reject(tx.error || new Error("indexeddb read aborted"));
      });
    } catch (_) {
      return null;
    } finally {
      try { db?.close?.(); } catch (_) {}
    }
  }

  async function readDurableJournals() {
    let db = null;
    try {
      db = await openPersistenceDatabase();
      return await new Promise((resolve, reject) => {
        const journals = [];
        const tx = db.transaction(PERSISTENCE_DB_STORE, "readonly");
        const store = tx.objectStore(PERSISTENCE_DB_STORE);
        const request = store.openCursor();
        request.onsuccess = () => {
          const cursor = request.result;
          if (!cursor) return;
          if (String(cursor.key || "").startsWith(PREHYDRATION_JOURNAL_DB_PREFIX)) {
            const journal = decodePreHydrationJournal(cursor.value);
            if (journal) journals.push(journal);
          }
          cursor.continue();
        };
        request.onerror = () => reject(request.error || new Error("indexeddb journal read failed"));
        tx.oncomplete = () => resolve(journals);
        tx.onerror = () => reject(tx.error || new Error("indexeddb journal transaction failed"));
        tx.onabort = () => reject(tx.error || new Error("indexeddb journal read aborted"));
      });
    } catch (_) {
      return [];
    } finally {
      try { db?.close?.(); } catch (_) {}
    }
  }

  async function writeDurableJournal(journalInput) {
    const journal = decodePreHydrationJournal(journalInput);
    if (!journal) return false;
    let db = null;
    try {
      db = await openPersistenceDatabase();
      return await new Promise((resolve, reject) => {
        const tx = db.transaction(PERSISTENCE_DB_STORE, "readwrite");
        tx.objectStore(PERSISTENCE_DB_STORE).put(journal, `${PREHYDRATION_JOURNAL_DB_PREFIX}${journal.actorId || persistenceActorId}`);
        tx.oncomplete = () => resolve(true);
        tx.onerror = () => reject(tx.error || new Error("indexeddb journal write failed"));
        tx.onabort = () => reject(tx.error || new Error("indexeddb journal write aborted"));
      });
    } catch (_) {
      return false;
    } finally {
      try { db?.close?.(); } catch (_) {}
    }
  }

  async function removeDurableJournals(maxGeneration = persistenceGeneration) {
    let db = null;
    try {
      db = await openPersistenceDatabase();
      await new Promise((resolve, reject) => {
        const tx = db.transaction(PERSISTENCE_DB_STORE, "readwrite");
        const store = tx.objectStore(PERSISTENCE_DB_STORE);
        const request = store.openCursor();
        request.onsuccess = () => {
          const cursor = request.result;
          if (!cursor) return;
          if (String(cursor.key || "").startsWith(PREHYDRATION_JOURNAL_DB_PREFIX)) {
            const journal = decodePreHydrationJournal(cursor.value);
            if (!journal || journal.baseGeneration <= maxGeneration) cursor.delete();
          }
          cursor.continue();
        };
        request.onerror = () => reject(request.error || new Error("indexeddb journal cleanup failed"));
        tx.oncomplete = () => resolve(true);
        tx.onerror = () => reject(tx.error || new Error("indexeddb journal cleanup transaction failed"));
        tx.onabort = () => reject(tx.error || new Error("indexeddb journal cleanup aborted"));
      });
    } catch (_) {
      return false;
    } finally {
      try { db?.close?.(); } catch (_) {}
    }
    return true;
  }

  async function writeDurableEnvelope(envelopeInput) {
    const incoming = normalizePersistenceCandidate(envelopeInput);
    if (!incoming) return null;
    let db = null;
    try {
      db = await openPersistenceDatabase();
      return await new Promise((resolve, reject) => {
        const tx = db.transaction(PERSISTENCE_DB_STORE, "readwrite");
        const store = tx.objectStore(PERSISTENCE_DB_STORE);
        const request = store.get(PERSISTENCE_DB_KEY);
        let committed = incoming;
        request.onsuccess = () => {
          const existing = normalizePersistenceCandidate(request.result);
          if (existing?.generation > incoming.generation) {
            committed = existing;
          } else if (existing?.generation === incoming.generation) {
            committed = mergePersistenceEnvelopes([existing, incoming], { incrementRevision: true });
          }
          if (existing?.generation > incoming.generation) return;
          try { store.put(committed, PERSISTENCE_DB_KEY); }
          catch (error) { reject(error); }
        };
        request.onerror = () => reject(request.error || new Error("indexeddb read before write failed"));
        tx.oncomplete = () => resolve(committed);
        tx.onerror = () => reject(tx.error || new Error("indexeddb write failed"));
        tx.onabort = () => reject(tx.error || new Error("indexeddb write aborted"));
      });
    } catch (_) {
      return null;
    } finally {
      try { db?.close?.(); } catch (_) {}
    }
  }

  function handleExternalPersistenceEnvelope(envelopeInput, options = {}) {
    const envelope = normalizePersistenceCandidate(envelopeInput);
    if (!envelope) return false;
    const changed = adoptPersistenceEnvelope(envelope);
    if (!changed) return false;
    const merged = mergePersistenceEnvelopes([persistenceEnvelope(), envelope], { incrementRevision: true });
    adoptPersistenceEnvelope(merged);
    writeEnvelopeToWebStorage(merged);
    if (options.broadcast !== false) broadcastPersistenceEnvelope(merged);
    durableWriteQueue = durableWriteQueue.then(
      () => writeDurableEnvelope(merged),
      () => writeDurableEnvelope(merged),
    ).then(committed => {
      if (!committed) return null;
      const durableChanged = adoptPersistenceEnvelope(committed);
      writeEnvelopeToWebStorage(committed);
      if (durableChanged) {
        broadcastPersistenceEnvelope(committed);
        render({ forceList: true });
      }
      return committed;
    });
    render({ forceList: true });
    return true;
  }

  function setupPersistenceCrossTabSync() {
    try {
      if (typeof global.BroadcastChannel === "function") {
        persistenceChannel = new global.BroadcastChannel(PERSISTENCE_CHANNEL_NAME);
        persistenceChannel.addEventListener?.("message", event => {
          handleExternalPersistenceEnvelope(event?.data, { broadcast: true });
        });
      }
    } catch (_) {
      persistenceChannel = null;
    }
    global.addEventListener?.("storage", event => {
      if (![STORAGE_KEY, STORAGE_BACKUP_KEY].includes(String(event?.key || ""))) return;
      handleExternalPersistenceEnvelope(event?.newValue, { broadcast: true });
    });
  }

  function persistStateNow() {
    persistenceDirty = false;
    const current = persistenceEnvelope();
    const envelope = mergePersistenceEnvelopes([current, ...webStorageCandidates()], { incrementRevision: true });
    adoptPersistenceEnvelope(envelope);
    const stored = writeEnvelopeToWebStorage(envelope);
    broadcastPersistenceEnvelope(envelope);
    durableWriteQueue = durableWriteQueue.then(
      () => writeDurableEnvelope(envelope),
      () => writeDurableEnvelope(envelope),
    ).then(committed => {
      if (!committed) return null;
      const changed = adoptPersistenceEnvelope(committed);
      writeEnvelopeToWebStorage(committed);
      if (changed) {
        broadcastPersistenceEnvelope(committed);
        render({ forceList: true });
      }
      return committed;
    });
    return stored;
  }

  function saveState() {
    persistenceDirty = true;
    if (!persistenceHydrated) {
      const journal = currentPreHydrationJournal();
      const stored = writePreHydrationJournalToWebStorage(journal);
      durableWriteQueue = durableWriteQueue.then(
        () => writeDurableJournal(journal),
        () => writeDurableJournal(journal),
      );
      return stored;
    }
    return persistStateNow();
  }

  async function hydrateDurableState() {
    try {
      const persistRequest = global.navigator?.storage?.persist?.();
      persistRequest?.catch?.(() => false);
    } catch (_) {}

    const [currentDurable, previousDurable, olderDurable, legacyDurable, ancientDurable, durableJournals] = await Promise.all([
      readDurableEnvelope(PERSISTENCE_DB_NAME),
      readDurableEnvelope(PREVIOUS_PERSISTENCE_DB_NAME),
      readDurableEnvelope(OLDER_PERSISTENCE_DB_NAME),
      readDurableEnvelope(LEGACY_PERSISTENCE_DB_NAME),
      readDurableEnvelope(ANCIENT_PERSISTENCE_DB_NAME),
      readDurableJournals(),
    ]);
    const currentCandidates = [...webStorageCandidates(), currentDurable].filter(Boolean);
    const currentGeneration = currentCandidates.length
      ? Math.max(...currentCandidates.map(candidate => candidate.generation))
      : 0;
    const migrationComplete = currentCandidates.some(candidate => candidate.migrationComplete);
    const legacyCandidates = currentGeneration === 0 && !migrationComplete
      ? [...legacyWebStorageCandidates(), previousDurable, olderDurable, legacyDurable, ancientDurable].filter(Boolean)
      : [];
    const baseEnvelope = mergePersistenceEnvelopes([...currentCandidates, ...legacyCandidates]);
    const preHydrationDelta = growOnlyStateDelta(initialPersistenceBaseline, state);
    const journals = [...webStorageJournals(), ...durableJournals]
      .filter(journal => journal.baseGeneration === baseEnvelope.generation);

    let mergedState = baseEnvelope.state;
    if (initialPersistence.generation === baseEnvelope.generation) {
      mergedState = mergeStateData(mergedState, preHydrationDelta);
    }
    for (const journal of journals) mergedState = mergeStateData(mergedState, journal.delta);

    persistenceGeneration = baseEnvelope.generation;
    persistenceRevision = baseEnvelope.revision;
    state = normalizeState(mergedState);
    state.resetPending = Boolean(baseEnvelope.state.resetPending);
    persistenceHydrated = true;
    persistStateNow();
    await durableWriteQueue.catch(() => null);
    removeWebStorageJournals(persistenceGeneration);
    await removeDurableJournals(persistenceGeneration);
    render({ forceList: true });
    return true;
  }

  function scheduleProgressSave(delay = 350) {
    if (scheduledProgressSaveTimer) return;
    scheduledProgressSaveTimer = global.setTimeout(() => {
      scheduledProgressSaveTimer = 0;
      saveState();
    }, Math.max(0, Number(delay) || 0));
  }

  function markProgressMutation() {
    progressMutationRevision += 1;
    if (!DEBUG_MODE && global.location?.protocol !== "file:") schedulePendingSync();
  }

  function createPlayerId() {
    if (global.crypto?.randomUUID) return global.crypto.randomUUID();
    const hex = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx";
    return hex.replace(/[xy]/g, char => {
      const value = Math.floor(Math.random() * 16);
      return (char === "x" ? value : ((value & 3) | 8)).toString(16);
    });
  }

  function createPlayerSecret() {
    const bytes = new Uint8Array(32);
    if (global.crypto?.getRandomValues) global.crypto.getRandomValues(bytes);
    else for (let i = 0; i < bytes.length; i++) bytes[i] = Math.floor(Math.random() * 256);
    return [...bytes].map(value => value.toString(16).padStart(2, "0")).join("");
  }

  function storageServerIdentity(storage) {
    try {
      return normalizeServerIdentity({
        playerId: storage?.getItem?.(PLAYER_KEY),
        playerSecret: storage?.getItem?.(PLAYER_SECRET_KEY),
      });
    } catch (_) {
      return null;
    }
  }

  function legacyPlayerId() {
    const candidates = [];
    for (const storage of [global.localStorage, global.sessionStorage]) {
      try {
        candidates.push(storage?.getItem?.(LEGACY_PLAYER_KEY));
        candidates.push(storage?.getItem?.(PLAYER_KEY));
      } catch (_) {}
    }
    candidates.push(legacyPlayerId.memory);
    const legacyId = candidates.map(value => String(value || "")).find(value => LEGACY_PLAYER_ID_PATTERN.test(value)) || "";
    if (!legacyId) return "";
    legacyPlayerId.memory = legacyId;
    for (const storage of [global.localStorage, global.sessionStorage]) {
      try { storage?.setItem?.(LEGACY_PLAYER_KEY, legacyId); } catch (_) {}
    }
    return legacyId;
  }

  function clearLegacyPlayerId() {
    legacyPlayerId.memory = "";
    for (const storage of [global.localStorage, global.sessionStorage]) {
      try { storage?.removeItem?.(LEGACY_PLAYER_KEY); } catch (_) {}
    }
  }

  function currentServerIdentity() {
    return storageServerIdentity(global.localStorage)
      || storageServerIdentity(global.sessionStorage)
      || normalizeServerIdentity(state?.serverIdentity)
      || normalizeServerIdentity(currentServerIdentity.memory);
  }

  function persistServerIdentity(identityInput, options = {}) {
    const identity = normalizeServerIdentity(identityInput);
    if (!identity) return false;
    currentServerIdentity.memory = identity;
    for (const storage of [global.localStorage, global.sessionStorage]) {
      try {
        storage?.setItem?.(PLAYER_KEY, identity.playerId);
        storage?.setItem?.(PLAYER_SECRET_KEY, identity.playerSecret);
      } catch (_) {}
    }
    const before = normalizeServerIdentity(state?.serverIdentity);
    const changed = !before || before.playerId !== identity.playerId || before.playerSecret !== identity.playerSecret;
    if (state && typeof state === "object") state.serverIdentity = { ...identity };
    if (changed && options.save !== false) saveState();
    return true;
  }

  function ensureServerIdentity() {
    // Capture the legacy bearer ID before the current UUID overwrites the old
    // localStorage slot. It is retained until the server confirms the claim.
    legacyPlayerId();
    const existing = currentServerIdentity();
    if (existing) {
      persistServerIdentity(existing, { save: false });
      return existing;
    }
    const created = { playerId: createPlayerId(), playerSecret: createPlayerSecret() };
    persistServerIdentity(created);
    return created;
  }

  function playerId() {
    return ensureServerIdentity().playerId;
  }

  function playerSecret() {
    return ensureServerIdentity().playerSecret;
  }

  function storeServerCredentials(data) {
    const stored = persistServerIdentity({
      playerId: String(data?.playerId || "").toLowerCase(),
      playerSecret: String(data?.playerSecret || "").toLowerCase(),
    });
    if (stored && data?.legacyClaimed === true) clearLegacyPlayerId();
    return stored;
  }

  function unlockedCount() {
    return DEFINITIONS.reduce((sum, def) => sum + (state.unlocked[def.id] ? 1 : 0), 0);
  }

  function formatDate(timestamp) {
    const value = Number(timestamp) || 0;
    if (!value) return "";
    try {
      return new Intl.DateTimeFormat("ja-JP", {
        year: "numeric", month: "2-digit", day: "2-digit", hour: "2-digit", minute: "2-digit",
      }).format(new Date(value));
    } catch (_) {
      return new Date(value).toLocaleString();
    }
  }

  function percentageValue(id) {
    const item = shared.achievements?.[id];
    const value = Number(item?.percentage);
    return shared.connected && Number.isFinite(value) ? Math.max(0, Math.min(100, value)) : 0;
  }

  function percentageText(id) {
    return shared.connected ? `${percentageValue(id).toFixed(1)}%` : "--";
  }

  function achieverCountValue(id) {
    const value = Number(shared.achievements?.[id]?.unlockedPlayers);
    return shared.connected && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : null;
  }

  function achieverCountText(id) {
    const value = achieverCountValue(id);
    return value === null ? "--" : `${value}\u4eba`;
  }

  function sharedAchievementText(id) {
    return `達成率 ${percentageText(id)}（達成人数 ${achieverCountText(id)}）`;
  }

  function continuousPlayElapsedMs(now = Date.now()) {
    if (state.unlocked.continuous_play_24_hours) return CONTINUOUS_PLAY_24H_TARGET_MS;
    const timestamp = Number(now);
    if (!Number.isFinite(timestamp)) return Math.max(0, continuousPlayAccumulatedMs);
    const activeSegment = continuousPlayActive && !document.hidden && timestamp >= continuousPlayLastHeartbeatAt
      ? timestamp - continuousPlayLastHeartbeatAt
      : 0;
    return Math.max(0, continuousPlayAccumulatedMs + activeSegment);
  }

  function formatElapsed(ms = 0) {
    const totalSeconds = Math.max(0, Math.floor(Number(ms || 0) / 1000));
    const minutes = Math.floor(totalSeconds / 60);
    const seconds = totalSeconds % 60;
    return `${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}`;
  }

  function localProgressText(id) {
    const definition = definitionById.get(String(id || ""));
    const spec = definition?.progress || null;
    if (spec?.display) {
      const target = Math.max(1, Math.floor(Number(spec.target || 0) || 0));
      let count = 0;
      if (spec.type === "counter") count = progressCounter(spec.key);
      else if (spec.type === "value") count = Math.max(0, Math.floor(Number(ensureProgress()[spec.key] || 0) || 0));
      else if (spec.type === "unique") count = ensureProgress()[spec.key]?.length || 0;
      count = state.unlocked[id] ? target : Math.min(target, count);
      const unit = String(spec.unit || "");
      if (spec.display === "percent") return `現在の達成率 ${(count / target * 100).toFixed(1)}%（${count} / ${target}${unit}）`;
      return `現在 ${count} / ${target}${unit}`;
    }
    if (id === "elite_few") {
      const world = global.world || null;
      const dayLength = Math.max(1, Number(world?.config?.dayLength ?? global.CONFIG?.dayLength ?? 120) || 120);
      const now = Math.max(0, Number(world?.time || 0) || 0);
      const startedAt = Number(world?.achievementEliteFewStartAt);
      const elapsedDays = Number.isFinite(startedAt) && startedAt >= 0 && now >= startedAt
        ? Math.min(ELITE_FEW_TARGET_DAYS, (now - startedAt) / dayLength)
        : 0;
      const aliveCount = (world?.tarinai || []).reduce((count, tarinai) => count + (tarinai && !tarinai.dead ? 1 : 0), 0);
      return `現在 ${elapsedDays.toFixed(1)} / ${ELITE_FEW_TARGET_DAYS}日（個体数 ${aliveCount} / ${ELITE_FEW_MAX_POPULATION}以下）`;
    }
    if (id === "continuous_play_1_hour") {
      const elapsed = Math.min(CONTINUOUS_PLAY_TARGET_MS, continuousPlayElapsedMs());
      return `現在の達成率 ${(elapsed / CONTINUOUS_PLAY_TARGET_MS * 100).toFixed(1)}%（${formatElapsed(elapsed)} / 60:00）`;
    }
    if (id === "continuous_play_24_hours") {
      const elapsed = Math.min(CONTINUOUS_PLAY_24H_TARGET_MS, continuousPlayElapsedMs());
      return `現在の達成率 ${(elapsed / CONTINUOUS_PLAY_24H_TARGET_MS * 100).toFixed(1)}%（${formatElapsed(elapsed)} / 1440:00）`;
    }
    if (id === "enemy_enemy_friend") {
      const world = global.world || null;
      const count = state.unlocked[id] ? 10 : Math.min(10, Math.max(0, Math.floor(Number(world?.achievementEnemyAntKills || 0) || 0)));
      return `現在の達成率 ${(count * 10).toFixed(1)}%（${count} / 10体）`;
    }
    return "";
  }

  function lockedDescriptionText(definition) {
    return PRE_UNLOCK_DESCRIPTION_IDS.has(definition.id) ? definition.description : "\uff1f\uff1f\uff1f";
  }

  function achievementListSignature() {
    const unlocks = DEFINITIONS.map(definition => Number(state.unlocked[definition.id] || 0) || 0).join(",");
    const rates = shared.connected
      ? DEFINITIONS.map(definition => `${percentageValue(definition.id).toFixed(1)}:${achieverCountValue(definition.id) ?? "-"}`).join(",")
      : shared.loading ? "loading" : "offline";
    const local = [
      progressCounter("birthCount"),
      Math.floor(continuousPlayElapsedMs() / 1000),
      Math.max(0, Math.floor(Number(global.__tarinaiFps || 0) || 0)),
      Math.min(10, Math.max(0, Number(global.world?.achievementEnemyAntKills || 0) || 0)),
      progressCounter("firstAidHeals"),
      progressCounter("fightMochiFightCount"),
      progressCounter("loveMochiBirthCount"),
      Math.min(DAILY_PLAY_TARGET, Math.max(0, Number(state.progress?.dailyPlayStreak || 0) || 0)),
      Math.max(0, Number(state.progress?.dailyPlayLastDay || 0) || 0),
      progressCounter("statsButtonPressCount"),
      progressCounter("totalDeathCount"),
      progressCounter("manualTarinaiAddedCount"),
      progressCounter("directFeedCount"),
      progressCounter("robotCleanCount"),
      Math.min(MAD_SCIENTIST_TARGET, state.progress?.mysteryDrugTarinaiIds?.length || 0),
      Math.floor(Math.max(0, (Number(global.world?.time || 0) || 0) - Math.max(0, Number(global.world?.achievementEliteFewStartAt || 0) || 0)) / Math.max(1, Number(global.world?.config?.dayLength ?? global.CONFIG?.dayLength ?? 120) || 120) * 10),
    ].join(":");
    return `${unlocks}|${rates}|${local}`;
  }

  function createAchievementCard(definition) {
    const unlockedAt = Number(state.unlocked[definition.id] || 0) || 0;
    const rate = percentageValue(definition.id);
    const card = document.createElement("article");
    card.className = `achievement-entry ${unlockedAt ? "unlocked" : "locked"}`;
    card.dataset.achievementId = definition.id;
    card.style.setProperty("--achievement-rate", `${rate}%`);

    const icon = document.createElement("div");
    icon.className = "achievement-entry-icon";
    icon.textContent = unlockedAt ? "\u2605" : "\u2606";

    const copy = document.createElement("div");
    copy.className = "achievement-entry-copy";
    const heading = document.createElement("div");
    heading.className = "achievement-entry-heading";
    const title = document.createElement("strong");
    title.textContent = definition.title;
    const description = document.createElement("span");
    description.className = "achievement-entry-description";
    description.textContent = unlockedAt ? definition.description : lockedDescriptionText(definition);
    heading.append(title, description);

    const progressText = !unlockedAt && PRE_UNLOCK_DESCRIPTION_IDS.has(definition.id) ? localProgressText(definition.id) : "";
    if (progressText) {
      const progress = document.createElement("div");
      progress.className = "achievement-entry-progress";
      progress.textContent = progressText;
      copy.append(heading, progress);
    } else {
      copy.append(heading);
    }

    const meta = document.createElement("div");
    meta.className = "achievement-entry-meta";
    const status = document.createElement("span");
    status.textContent = unlockedAt ? `\u9054\u6210\u6e08\u307f ${formatDate(unlockedAt)}` : "";
    const percentage = document.createElement("span");
    percentage.className = "achievement-entry-percentage";
    percentage.textContent = sharedAchievementText(definition.id);
    meta.append(status, percentage);
    copy.append(meta);
    card.append(icon, copy);
    card.setAttribute("aria-label", `${definition.title}\u3002${description.textContent}\u3002${sharedAchievementText(definition.id)}`);
    return card;
  }

  function createAchievementGroup({ id, title, definitions, countText = "", open = false, emptyText = "" }) {
    const group = document.createElement("details");
    group.className = "achievement-group";
    group.dataset.achievementGroup = id;
    group.dataset.achievementCount = String(definitions.length);
    group.open = Boolean(open);
    const summary = document.createElement("summary");
    summary.className = "achievement-group-summary";
    const label = document.createElement("strong");
    label.textContent = title;
    const count = document.createElement("span");
    count.className = "achievement-group-count";
    count.textContent = countText;
    summary.append(label, count);
    const body = document.createElement("div");
    body.className = "achievement-group-body";
    if (definitions.length) body.append(...definitions.map(createAchievementCard));
    else {
      const empty = document.createElement("p");
      empty.className = "achievement-group-empty";
      empty.textContent = emptyText || "\u8a72\u5f53\u3059\u308b\u5b9f\u7e3e\u306f\u3042\u308a\u307e\u305b\u3093\u3002";
      body.append(empty);
    }
    group.append(summary, body);
    return group;
  }

  function render(options = {}) {
    const count = unlockedCount();
    if (dom.buttonCount) dom.buttonCount.textContent = `${count}/${DEFINITIONS.length}`;
    if (dom.dialogCount) dom.dialogCount.textContent = `${count} / ${DEFINITIONS.length}`;
    dom.button?.classList.toggle("complete", count === DEFINITIONS.length);
    if (dom.sharedStatus) {
      if (shared.loading) dom.sharedStatus.textContent = "\u5171\u6709\u9054\u6210\u7387\u3092\u78ba\u8a8d\u4e2d\u2026";
      else if (shared.connected) dom.sharedStatus.textContent = `共有集計（端末報告値）: ${shared.totalPlayers}人のプレイヤー`;
      else dom.sharedStatus.textContent = "\u5171\u6709\u9054\u6210\u7387: \u672a\u63a5\u7d9a\uff08\u30ed\u30fc\u30ab\u30eb\u5b9f\u7e3e\u306f\u5229\u7528\u53ef\u80fd\uff09";
    }
    if (!dom.list || dom.dialog?.classList.contains("hidden")) return;
    const signature = achievementListSignature();
    if (!options.forceList && signature === lastListSignature) return;
    lastListSignature = signature;

    const previousGroups = Array.from(dom.list.children || []);
    const hadPreviousGroups = previousGroups.some(group => group?.dataset?.achievementGroup);
    const openGroupIds = new Set(previousGroups.filter(group => group?.open).map(group => group.dataset.achievementGroup));
    const previousUnlockedCounts = new Map(previousGroups.map(group => [
      group?.dataset?.achievementGroup,
      Math.max(0, Number(group?.dataset?.achievementUnlockedCount || 0) || 0),
    ]));
    const groups = [];

    for (const category of ACHIEVEMENT_CATEGORIES) {
      const categoryDefinitions = CATEGORY_DEFINITIONS.get(category.id) || [];
      const unlockedDefinitions = categoryDefinitions
        .filter(definition => state.unlocked[definition.id])
        .sort((a, b) => Number(state.unlocked[b.id] || 0) - Number(state.unlocked[a.id] || 0));
      const lockedDefinitions = categoryDefinitions.filter(definition => !state.unlocked[definition.id]);
      const orderedDefinitions = [...unlockedDefinitions, ...lockedDefinitions];
      const previousUnlockedCount = previousUnlockedCounts.get(category.id) || 0;
      const group = createAchievementGroup({
        id: category.id,
        title: category.title,
        definitions: orderedDefinitions,
        countText: `${unlockedDefinitions.length} / ${categoryDefinitions.length}`,
        open: hadPreviousGroups
          ? (openGroupIds.has(category.id) || unlockedDefinitions.length > previousUnlockedCount)
          : category.id === "ecology",
      });
      group.dataset.achievementUnlockedCount = String(unlockedDefinitions.length);
      groups.push(group);
    }
    dom.list.replaceChildren(...groups);
  }

  function renderIfDialogOpen() {
    if (!dom.dialog?.classList.contains("hidden")) render();
  }

  function resetUnlockToastVisual() {
    if (!dom.toast) return;
    dom.toast.classList.remove("absorbing");
    dom.toast.style.removeProperty("--achievement-toast-dx");
    dom.toast.style.removeProperty("--achievement-toast-dy");
  }

  function finishUnlockToast() {
    dom.toast?.classList.add("hidden");
    resetUnlockToastVisual();
    dom.button?.classList.remove("achievement-absorb-target");
    toastActive = false;
    global.setTimeout(runNextUnlockToast, 80);
  }

  function absorbUnlockToast() {
    if (!dom.toast || dom.toast.classList.contains("hidden")) {
      finishUnlockToast();
      return;
    }
    const toastRect = dom.toast.getBoundingClientRect();
    const targetRect = dom.button?.getBoundingClientRect?.();
    if (!targetRect || !toastRect.width || !toastRect.height) {
      finishUnlockToast();
      return;
    }
    const dx = targetRect.left + targetRect.width / 2 - (toastRect.left + toastRect.width / 2);
    const dy = targetRect.top + targetRect.height / 2 - (toastRect.top + toastRect.height / 2);
    dom.toast.style.setProperty("--achievement-toast-dx", `${dx}px`);
    dom.toast.style.setProperty("--achievement-toast-dy", `${dy}px`);
    dom.toast.classList.add("absorbing");
    dom.button?.classList.add("achievement-absorb-target");
    clearTimeout(showUnlockToast.hideTimer);
    showUnlockToast.hideTimer = global.setTimeout(finishUnlockToast, 760);
  }

  function runNextUnlockToast() {
    if (toastActive || !toastQueue.length) return;
    const definition = toastQueue.shift();
    global.TarinaiAudio?.achievementUnlock?.();
    if (!dom.toast || !dom.toastTitle) {
      global.showToast?.(`\u5b9f\u7e3e\u89e3\u9664: ${definition.title} \u2014 ${definition.description || ""}`);
      global.setTimeout(runNextUnlockToast, 80);
      return;
    }
    toastActive = true;
    clearTimeout(showUnlockToast.absorbTimer);
    clearTimeout(showUnlockToast.hideTimer);
    resetUnlockToastVisual();
    dom.button?.classList.remove("achievement-absorb-target");
    dom.toastTitle.textContent = definition.title;
    if (dom.toastCondition) dom.toastCondition.textContent = definition.description || "";
    dom.toast.classList.remove("hidden");
    void dom.toast.offsetWidth;
    showUnlockToast.absorbTimer = global.setTimeout(absorbUnlockToast, 2700);
  }

  function showUnlockToast(definition) {
    if (!definition) return;
    toastQueue.push(definition);
    runNextUnlockToast();
  }

  function queuePending(id) {
    if (!state.pending.includes(id)) state.pending.push(id);
  }

  async function request(payload = null) {
    if (DEBUG_MODE || !API_URL || global.location?.protocol === "file:") throw new Error("api unavailable");
    const controller = typeof AbortController === "function" ? new AbortController() : null;
    const timeout = global.setTimeout(() => controller?.abort(), 3500);
    try {
      const options = payload ? {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({ ...payload, playerSecret: playerSecret() }),
        signal: controller?.signal,
        cache: "no-store",
      } : { signal: controller?.signal, cache: "no-store" };
      const url = payload ? API_URL : `${API_URL}?action=summary`;
      const response = await fetch(url, options);
      let data = null;
      try { data = await response.json(); } catch (_) {}
      if (!response.ok || !data?.ok) {
        const error = new Error(`api ${response.status || 0}`);
        error.status = Number(response.status || 0) || 0;
        error.code = String(data?.error || "api_rejected");
        error.data = data;
        throw error;
      }
      storeServerCredentials(data);
      return data;
    } finally {
      global.clearTimeout(timeout);
    }
  }

  function applyShared(data) {
    shared = {
      connected: true,
      loading: false,
      totalPlayers: Math.max(0, Number(data?.totalPlayers || 0) || 0),
      achievements: data?.achievements && typeof data.achievements === "object" ? data.achievements : {},
      statisticsTrust: String(data?.statisticsTrust || "client-reported"),
    };
    render();
  }

  async function refreshShared(options = {}) {
    const serial = ++requestSerial;
    shared.loading = true;
    render();
    try {
      const data = options.session ? await establishSession() : await request(null);
      if (serial === requestSerial) applyShared(data);
      return true;
    } catch (_) {
      if (serial === requestSerial) {
        shared = { ...shared, connected: false, loading: false };
        render();
      }
      return false;
    }
  }

  function localUnlockSnapshot() {
    const unlocked = {};
    for (const definition of DEFINITIONS) {
      const timestamp = Number(state.unlocked[definition.id] || 0) || 0;
      if (timestamp > 0 && !state.debugUnlocked?.includes?.(definition.id)) unlocked[definition.id] = timestamp;
    }
    return unlocked;
  }

  function localProgressSnapshot() {
    const normalized = normalizeState(state);
    return {
      progress: JSON.parse(JSON.stringify(normalized.progress)),
      ledger: JSON.parse(JSON.stringify(normalized._progressLedger)),
    };
  }

  function completionistTimestamp() {
    let latest = 0;
    for (const definition of DEFINITIONS) {
      if (definition.id === COMPLETIONIST_ID) continue;
      const timestamp = Number(state.unlocked[definition.id] || 0) || 0;
      if (!timestamp) return 0;
      latest = Math.max(latest, timestamp);
    }
    return latest;
  }

  function mergeServerUnlocks(data) {
    const serverGenerationRaw = Number(data?.playerGeneration);
    const hasServerGeneration = Number.isFinite(serverGenerationRaw) && serverGenerationRaw >= 0;
    const serverGeneration = hasServerGeneration ? Math.floor(serverGenerationRaw) : persistenceGeneration;
    if (serverGeneration < persistenceGeneration) return false;

    let changed = false;
    if (serverGeneration > persistenceGeneration) {
      // A reset committed by another tab/device wins over every older local tab.
      const identity = currentServerIdentity();
      persistenceGeneration = serverGeneration;
      persistenceRevision = 0;
      state = blankState();
      if (identity) state.serverIdentity = { ...identity };
      progressMutationRevision = 0;
      progressSyncedRevision = 0;
      changed = true;
    }

    const serverProgress = data?.playerProgress;
    if (serverProgress && typeof serverProgress === "object" && !Array.isArray(serverProgress)) {
      const beforeProgress = JSON.stringify({ progress: state.progress, ledger: state._progressLedger });
      const incoming = blankState();
      incoming.progress = serverProgress.progress && typeof serverProgress.progress === "object" ? serverProgress.progress : {};
      incoming._progressLedger = serverProgress.ledger && typeof serverProgress.ledger === "object" ? serverProgress.ledger : {};
      state = mergeStateData(state, incoming);
      const afterProgress = JSON.stringify({ progress: state.progress, ledger: state._progressLedger });
      if (beforeProgress !== afterProgress) changed = true;
    }

    const source = data?.playerUnlocked;
    if (source && typeof source === "object" && !Array.isArray(source)) {
      const serverIds = [];
      for (const [id, serverTimestamp] of Object.entries(source)) {
        if (!definitionById.has(id) || state.debugUnlocked?.includes?.(id)) continue;
        const seconds = Number(serverTimestamp);
        const serverTime = Number.isFinite(seconds) && seconds > 0 ? Math.max(1, Math.floor(seconds * 1000)) : Date.now();
        const localTime = Number(state.unlocked[id] || 0) || 0;
        const sameSecond = localTime > 0 && Math.floor(localTime / 1000) === Math.floor(serverTime / 1000);
        const mergedTime = localTime > 0 ? (sameSecond ? localTime : Math.min(localTime, serverTime)) : serverTime;
        if (localTime !== mergedTime) {
          state.unlocked[id] = mergedTime;
          changed = true;
        }
        serverIds.push(id);
      }
      const confirmedSet = new Set(serverIds);
      const beforePending = state.pending.length;
      state.pending = state.pending.filter(id => !confirmedSet.has(id));
      if (state.pending.length !== beforePending) changed = true;
    }

    const completionTime = completionistTimestamp();
    if (completionTime > 0) {
      const current = Number(state.unlocked[COMPLETIONIST_ID] || 0) || 0;
      const merged = current > 0 ? Math.max(current, completionTime) : completionTime;
      if (current !== merged) {
        state.unlocked[COMPLETIONIST_ID] = merged;
        changed = true;
      }
    }
    if (changed) {
      saveState();
      render();
    }
    return changed;
  }

  async function establishSession(options = {}) {
    const legacyId = legacyPlayerId();
    const payload = {
      action: "session",
      playerId: playerId(),
      gameVersion: GAME_VERSION,
      generation: persistenceGeneration,
    };
    if (legacyId) payload.legacyPlayerId = legacyId;
    const data = await request(payload);
    if (options.merge !== false) mergeServerUnlocks(data);
    return data;
  }

  async function performSyncPending(options = {}) {
    let latest = null;
    const writeWithIdentityRecovery = async (payload, recoveryOptions = {}) => {
      try {
        const data = await request(payload);
        mergeServerUnlocks(data);
        return data;
      } catch (error) {
        const status = Number(error?.status || 0);
        const code = String(error?.code || "");
        if (status === 409 && code === "stale_generation") {
          // A reset from another device is authoritative. Merge it, but never
          // replay this request's older-generation unlock/progress snapshot.
          error.recoveredData = await establishSession({ merge: true });
          throw error;
        }
        if (status === 409 && code === "generation_ahead") {
          // Compatibility recovery for servers that require an explicit full
          // generation promotion after a backup restore or identity recreation.
          const data = await request({
            action: "sync",
            playerId: playerId(),
            gameVersion: GAME_VERSION,
            generation: persistenceGeneration,
            generationRecovery: true,
            syncProtocol: SYNC_PROTOCOL_VERSION,
            mergeMode: "grow-only-union-v5",
            unlocked: localUnlockSnapshot(),
            progressState: localProgressSnapshot(),
          });
          mergeServerUnlocks(data);
          return data;
        }
        const recoverableIdentity = status === 403 && ["unknown_player", "invalid_owner"].includes(code);
        if (!recoverableIdentity) throw error;
        const sessionData = await establishSession({ merge: true });
        if (recoveryOptions.sessionOnly) return sessionData;
        if (payload.action === "reset" && !state.resetPending) return sessionData;
        const retryPayload = payload.action === "sync" ? {
          action: "sync",
          playerId: playerId(),
          gameVersion: GAME_VERSION,
          generation: persistenceGeneration,
          generationRecovery: true,
          syncProtocol: SYNC_PROTOCOL_VERSION,
          mergeMode: "grow-only-union-v5",
          unlocked: localUnlockSnapshot(),
          progressState: localProgressSnapshot(),
        } : {
          ...payload,
          playerId: playerId(),
          generation: persistenceGeneration,
          generationRecovery: true,
          syncProtocol: SYNC_PROTOCOL_VERSION,
        };
        const data = await request(retryPayload);
        mergeServerUnlocks(data);
        return data;
      }
    };
    try {
      if (state.resetPending) {
        latest = await writeWithIdentityRecovery({
          action: "reset",
          playerId: playerId(),
          gameVersion: GAME_VERSION,
          confirmReset: "RESET_ACHIEVEMENTS",
          catalogRevision: ACHIEVEMENT_CATALOG_REVISION,
          generation: persistenceGeneration,
          syncProtocol: SYNC_PROTOCOL_VERSION,
        }, { mergeSession: false });
        state.resetPending = false;
        saveState();
      }

      // Unlocks and progress are uploaded as one generation-scoped CRDT
      // snapshot. The server unions actor shards, set-like progress and the
      // earliest unlock timestamps, then returns the atomic merged state.
      const snapshot = localUnlockSnapshot();
      const progressSnapshot = localProgressSnapshot();
      const progressRevisionAtStart = progressMutationRevision;
      const pendingIds = [...new Set(state.pending.filter(id => definitionById.has(id) && snapshot[id]))];
      const unlocked = options.full
        ? snapshot
        : Object.fromEntries(pendingIds.map(id => [id, snapshot[id]]));
      const syncedIds = Object.keys(unlocked);
      const hasProgressChanges = progressRevisionAtStart > progressSyncedRevision;
      if (options.full || syncedIds.length || hasProgressChanges) {
        latest = await writeWithIdentityRecovery({
          action: "sync",
          playerId: playerId(),
          gameVersion: GAME_VERSION,
          unlocked,
          progressState: progressSnapshot,
          mergeMode: "grow-only-union-v5",
          syncProtocol: SYNC_PROTOCOL_VERSION,
          generation: persistenceGeneration,
          generationRecovery: true,
        }, { mergeSession: false });
        const confirmedSet = new Set(syncedIds);
        state.pending = state.pending.filter(id => !confirmedSet.has(id));
        progressSyncedRevision = Math.max(progressSyncedRevision, progressRevisionAtStart);
        saveState();
      } else if (!latest) {
        return refreshShared({ session: true });
      }

      if (latest) applyShared(latest);
      return true;
    } catch (error) {
      if (error?.recoveredData) {
        applyShared(error.recoveredData);
        return true;
      }
      shared = { ...shared, connected: false, loading: false };
      render();
      return false;
    }
  }

  function syncPending(options = {}) {
    const normalized = { full: Boolean(options.full) };
    const run = async () => {
      await persistenceReadyPromise;
      return performSyncPending(normalized);
    };
    syncQueue = syncQueue.then(run, run);
    return syncQueue;
  }

  function schedulePendingSync() {
    if (scheduledSyncTimer) global.clearTimeout(scheduledSyncTimer);
    scheduledSyncTimer = global.setTimeout(() => {
      scheduledSyncTimer = 0;
      void syncPending();
    }, SYNC_DEBOUNCE_MS);
  }

  function allOtherAchievementsUnlocked() {
    return DEFINITIONS.every(definition => definition.id === COMPLETIONIST_ID || Boolean(state.unlocked[definition.id]));
  }

  function unlock(id, detail = {}) {
    const definition = definitionById.get(String(id || ""));
    if (!definition || state.unlocked[definition.id]) return false;
    const now = Date.now();
    const unlockedNow = [{ definition, detail }];
    state.unlocked[definition.id] = now;
    if (definition.id !== COMPLETIONIST_ID && !state.unlocked[COMPLETIONIST_ID] && allOtherAchievementsUnlocked()) {
      const completionist = definitionById.get(COMPLETIONIST_ID);
      state.unlocked[COMPLETIONIST_ID] = now;
      unlockedNow.push({ definition: completionist, detail: { source: "all-achievements", trigger: definition.id } });
    }
    for (const entry of unlockedNow) {
      if (DEBUG_MODE) {
        if (!Array.isArray(state.debugUnlocked)) state.debugUnlocked = [];
        if (!state.debugUnlocked.includes(entry.definition.id)) state.debugUnlocked.push(entry.definition.id);
      } else {
        queuePending(entry.definition.id);
      }
    }
    saveState();
    render({ forceList: true });
    for (const entry of unlockedNow) {
      showUnlockToast(entry.definition);
      global.TarinaiEvents?.emit?.("achievement:unlocked", { achievement: entry.definition, detail: entry.detail });
    }
    if (!DEBUG_MODE) schedulePendingSync();
    return true;
  }

  function runtimeTracker(world, now = 0) {
    if (!world || (typeof world !== "object" && typeof world !== "function")) return null;
    let tracker = runtimeByWorld.get(world);
    if (!tracker) {
      tracker = {
        lastTime: Number(now) || 0,
        birthTimes: [],
        deathTimes: [],
      };
      runtimeByWorld.set(world, tracker);
    }
    const time = Number(now) || 0;
    if (time + 0.001 < tracker.lastTime) {
      tracker.birthTimes = [];
      tracker.deathTimes = [];
    }
    tracker.lastTime = time;
    return tracker;
  }

  function recordNaturalGeneration(world, tarinai, depthKey, required) {
    if (!world || !tarinai) return 0;
    const parentIds = Array.isArray(tarinai.parents) ? tarinai.parents.filter(Boolean) : [];
    let parentDepth = 0;
    for (const parentId of parentIds) {
      const parent = (world.tarinai || []).find(candidate => candidate
        && String(candidate.familyKey || candidate.id || "") === String(parentId));
      parentDepth = Math.max(parentDepth, Math.max(0, Math.floor(Number(parent?.[depthKey] || 0) || 0)));
    }
    tarinai[depthKey] = Math.max(1, parentDepth + 1);
    return tarinai[depthKey] >= required ? tarinai[depthKey] : 0;
  }

  function detailWorld(detail = {}) {
    return detail.world || detail.item?.world || detail.tarinai?.world || detail.ant?.world || global.world || null;
  }

  function recordIntervention(detail = {}) {
    const world = detailWorld(detail);
    if (!world) return false;
    world.achievementLastInterventionAt = Math.max(0, Number(world.time || 0) || 0);
    return true;
  }

  function ensureProgress() {
    if (!state.progress || typeof state.progress !== "object") state.progress = blankState().progress;
    if (!Array.isArray(state.progress.linkTypes)) state.progress.linkTypes = [];
    state.progress.linkTypes = [...new Set(state.progress.linkTypes.filter(type => LINK_PROGRESS_TYPES.includes(type)))];
    state.progress.signalActivated = Boolean(state.progress.signalActivated);
    if (!Array.isArray(state.progress.medicineTypes)) state.progress.medicineTypes = [];
    state.progress.medicineTypes = [...new Set(state.progress.medicineTypes.filter(type => MEDICINE_LEDGER_TYPES.includes(type)))];
    state.progress.dailyPlayStreak = Math.min(DAILY_PLAY_TARGET, Math.max(0, Math.floor(Number(state.progress.dailyPlayStreak || 0) || 0)));
    state.progress.dailyPlayLastDay = Math.max(0, Math.floor(Number(state.progress.dailyPlayLastDay || 0) || 0));
    if (!Array.isArray(state.progress.mysteryDrugTarinaiIds)) state.progress.mysteryDrugTarinaiIds = [];
    state.progress.mysteryDrugTarinaiIds = [...new Set(state.progress.mysteryDrugTarinaiIds.map(id => String(id || "")).filter(Boolean))].slice(0, MAD_SCIENTIST_TARGET);
    return state.progress;
  }

  function ensureProgressLedger() {
    state._progressLedger = sanitizeProgressLedger(state, state.progress || {});
    return state._progressLedger;
  }

  function progressCounter(key) {
    return ledgerCounterValue(ensureProgressLedger(), key);
  }

  function raiseProgressCounter(key, minimumValue = 0) {
    if (!Object.prototype.hasOwnProperty.call(ADDITIVE_PROGRESS_CAPS, key)) return 0;
    const cap = ADDITIVE_PROGRESS_CAPS[key];
    const ledger = ensureProgressLedger();
    const current = ledgerCounterValue(ledger, key);
    const target = Math.min(cap, Math.max(0, Math.floor(Number(minimumValue || 0) || 0)));
    if (target <= current) return current;
    ledger.base[key] = Math.min(cap, Math.max(0, Math.floor(Number(ledger.base[key] || 0) || 0)) + (target - current));
    if (target >= cap) {
      ledger.base[key] = cap;
      ledger.shards[key] = {};
    }
    markProgressMutation();
    return target;
  }

  function incrementProgressCounter(key, amount = 1) {
    if (!Object.prototype.hasOwnProperty.call(ADDITIVE_PROGRESS_CAPS, key)) return 0;
    const ledger = ensureProgressLedger();
    const cap = ADDITIVE_PROGRESS_CAPS[key];
    const current = ledgerCounterValue(ledger, key);
    const increment = Math.min(Math.max(0, Math.floor(Number(amount || 0) || 0)), Math.max(0, cap - current));
    if (increment <= 0) return current;
    const shards = ledger.shards[key] || (ledger.shards[key] = {});
    shards[persistenceActorId] = Math.max(0, Math.floor(Number(shards[persistenceActorId] || 0) || 0)) + increment;
    if (current + increment >= cap) {
      ledger.base[key] = cap;
      ledger.shards[key] = {};
    }
    markProgressMutation();
    return current + increment;
  }

  function unlockedIndexesFromMaskWords(lowWord = 0, highWord = 0, extraWord = 0) {
    const low = Math.max(0, Math.min(0xffffffff, Math.floor(Number(lowWord) || 0)));
    const high = Math.max(0, Math.min(0xffffffff, Math.floor(Number(highWord) || 0)));
    const extraMax = (2 ** Math.max(0, DEFINITIONS.length - 64)) - 1;
    const extra = Math.max(0, Math.min(extraMax, Math.floor(Number(extraWord) || 0)));
    const indexes = [];
    for (let index = 0; index < DEFINITIONS.length; index += 1) {
      const word = index < 32 ? low : (index < 64 ? high : extra);
      const bit = index < 32 ? index : (index < 64 ? index - 32 : index - 64);
      if (Math.floor(word / (2 ** bit)) % 2) indexes.push(index);
    }
    return indexes;
  }

  function exportSpellState() {
    let lowWord = 0;
    let highWord = 0;
    let extraWord = 0;
    const timestamps = [];
    for (let index = 0; index < DEFINITIONS.length; index += 1) {
      const id = DEFINITIONS[index].id;
      const timestamp = Number(state.unlocked[id] || 0) || 0;
      if (timestamp <= 0 || state.debugUnlocked?.includes?.(id)) continue;
      if (index < 32) lowWord += 2 ** index;
      else if (index < 64) highWord += 2 ** (index - 32);
      else extraWord += 2 ** (index - 64);
      timestamps.push(Math.max(1, Math.floor(timestamp / 60000)));
    }
    const baseTimestamp = timestamps.length ? Math.min(...timestamps) : 0;
    const deltas = timestamps.map(timestamp => Math.max(0, timestamp - baseTimestamp));
    const progress = ensureProgress();
    let linkFlags = progress.signalActivated ? 8 : 0;
    if (progress.linkTypes.includes("rope")) linkFlags |= 1;
    if (progress.linkTypes.includes("rod")) linkFlags |= 2;
    if (progress.linkTypes.includes("spring")) linkFlags |= 4;
    let medicineMask = 0;
    MEDICINE_LEDGER_TYPES.forEach((type, index) => {
      if (progress.medicineTypes.includes(type)) medicineMask |= (1 << index);
    });
    return [
      SPELL_STATE_VERSION,
      lowWord >>> 0,
      highWord >>> 0,
      extraWord >>> 0,
      baseTimestamp,
      deltas,
      [
        state.unlocked.placed_objects_100 ? 0 : Math.min(100, progressCounter("placementCount")),
        state.unlocked.mechanized_industry ? 0 : linkFlags,
        state.unlocked.ants_killed_100 ? 0 : Math.min(100, progressCounter("antKills")),
        state.unlocked.great_mother_1000_births ? 0 : Math.min(3333, progressCounter("birthCount")),
        state.unlocked.unplanned_city_30 ? 0 : Math.min(30, progressCounter("quickDeleteCount")),
        state.unlocked.undo_20 ? 0 : Math.min(20, progressCounter("undoCount")),
        state.unlocked.redo_20 ? 0 : Math.min(20, progressCounter("redoCount")),
        state.unlocked.medicine_ledger_all ? 0 : medicineMask,
        state.unlocked.town_doctor_50 ? 0 : Math.min(50, progressCounter("firstAidHeals")),
        state.unlocked.chaos_seeker_666_fights ? 0 : Math.min(CHAOS_FIGHT_TARGET, progressCounter("fightMochiFightCount")),
        state.unlocked.sniper_333_shots ? 0 : Math.min(SNIPER_SHOT_TARGET, progressCounter("shotCount")),
        state.unlocked.fertility_seeker_721_love_births ? 0 : Math.min(FERTILITY_BIRTH_TARGET, progressCounter("loveMochiBirthCount")),
        state.unlocked.daily_play_7_days ? 0 : Math.min(DAILY_PLAY_TARGET, progress.dailyPlayStreak),
        state.unlocked.daily_play_7_days ? 0 : Math.min(131071, progress.dailyPlayLastDay),
        state.unlocked.statistician ? 0 : Math.min(STATISTICIAN_TARGET, progressCounter("statsButtonPressCount")),
        state.unlocked.memento_mori ? 0 : Math.min(MEMENTO_MORI_TARGET, progressCounter("totalDeathCount")),
        state.unlocked.lively_making ? 0 : Math.min(LIVELY_MAKING_TARGET, progressCounter("manualTarinaiAddedCount")),
        state.unlocked.mad_scientist ? 0 : Math.min(MAD_SCIENTIST_TARGET, progress.mysteryDrugTarinaiIds.length),
        state.unlocked.direct_feed_33 ? 0 : Math.min(33, progressCounter("directFeedCount")),
        state.unlocked.robot_cleaner_100 ? 0 : Math.min(ROBOT_CLEAN_TARGET, progressCounter("robotCleanCount")),
      ],
      state.unlocked.mad_scientist ? [] : progress.mysteryDrugTarinaiIds.slice(0, MAD_SCIENTIST_TARGET),
    ];
  }

  function parseSpellState(payload = null) {
    if (!Array.isArray(payload)) return null;
    const version = Number(payload[0]);
    if (![9, 10, SPELL_STATE_VERSION].includes(version)) return null;
    const lowWord = Number(payload[1]);
    const highWord = Number(payload[2]);
    const extraWord = Number(payload[3]);
    const extraMax = (2 ** Math.max(0, DEFINITIONS.length - 64)) - 1;
    if (!Number.isSafeInteger(lowWord) || lowWord < 0 || lowWord > 0xffffffff ||
        !Number.isSafeInteger(highWord) || highWord < 0 || highWord > 0xffffffff ||
        !Number.isSafeInteger(extraWord) || extraWord < 0 || extraWord > extraMax) {
      throw new Error("invalid achievement spell mask");
    }
    return {
      unlockedIndexes: unlockedIndexesFromMaskWords(lowWord, highWord, extraWord),
      baseTimestamp: Math.max(0, Math.floor(Number(payload[4] || 0) || 0)),
      deltas: Array.isArray(payload[5]) ? payload[5] : [],
      packed: Array.isArray(payload[6]) ? payload[6] : [],
      mysteryDrugIds: version >= 10 && Array.isArray(payload[7])
        ? [...new Set(payload[7].map(id => String(id || "")).filter(Boolean))].slice(0, MAD_SCIENTIST_TARGET)
        : [],
      version,
      timestampUnitMs: 60000,
    };
  }

  function importSpellState(payload = null) {
    const parsed = parseSpellState(payload);
    if (!parsed) return { included: false, unlockedAdded: 0, progressChanged: false };
    const { unlockedIndexes, baseTimestamp, deltas, packed, mysteryDrugIds, version, timestampUnitMs } = parsed;
    if (deltas.length !== unlockedIndexes.length) throw new Error("invalid achievement spell timestamps");
    const importedUnlocks = [];
    let importedCompletionistAt = 0;
    unlockedIndexes.forEach((definitionIndex, orderIndex) => {
      const definition = DEFINITIONS[definitionIndex];
      if (!definition) return;
      const delta = Math.max(0, Math.floor(Number(deltas[orderIndex] || 0) || 0));
      const timestamp = Math.max(1, (baseTimestamp + delta) * timestampUnitMs);
      if (definition.id === COMPLETIONIST_ID) {
        importedCompletionistAt = timestamp;
        return;
      }
      importedUnlocks.push([definition.id, timestamp]);
    });

    let unlockedAdded = 0;
    let changed = false;
    for (const [id, timestamp] of importedUnlocks) {
      const current = Number(state.unlocked[id] || 0) || 0;
      if (!current) {
        state.unlocked[id] = timestamp;
        queuePending(id);
        unlockedAdded += 1;
        changed = true;
      } else if (timestamp < current) {
        state.unlocked[id] = timestamp;
        changed = true;
      }
    }

    const progress = ensureProgress();
    const previousProgress = JSON.stringify({ progress, ledger: ensureProgressLedger() });
    raiseProgressCounter("placementCount", packed[0]);
    const linkFlags = Math.max(0, Math.floor(Number(packed[1] || 0) || 0));
    const importedLinks = [];
    if (linkFlags & 1) importedLinks.push("rope");
    if (linkFlags & 2) importedLinks.push("rod");
    if (linkFlags & 4) importedLinks.push("spring");
    progress.linkTypes = [...new Set([...(progress.linkTypes || []), ...importedLinks])];
    progress.signalActivated = Boolean(progress.signalActivated || (linkFlags & 8));
    raiseProgressCounter("antKills", packed[2]);
    raiseProgressCounter("birthCount", packed[3]);
    raiseProgressCounter("quickDeleteCount", packed[4]);
    raiseProgressCounter("undoCount", packed[5]);
    raiseProgressCounter("redoCount", packed[6]);
    const medicineMask = Math.max(0, Math.floor(Number(packed[7] || 0) || 0));
    const importedMedicines = MEDICINE_LEDGER_TYPES.filter((_type, index) => medicineMask & (1 << index));
    progress.medicineTypes = [...new Set([...(progress.medicineTypes || []), ...importedMedicines])];
    raiseProgressCounter("firstAidHeals", packed[8]);
    raiseProgressCounter("fightMochiFightCount", packed[9]);
    raiseProgressCounter("shotCount", packed[10]);
    raiseProgressCounter("loveMochiBirthCount", packed[11]);
    const importedDailyStreak = Math.min(DAILY_PLAY_TARGET, Math.max(0, Math.floor(Number(packed[12] || 0) || 0)));
    const importedDailyLastDay = Math.min(131071, Math.max(0, Math.floor(Number(packed[13] || 0) || 0)));
    if (importedDailyLastDay > progress.dailyPlayLastDay) {
      progress.dailyPlayLastDay = importedDailyLastDay;
      progress.dailyPlayStreak = importedDailyStreak;
    } else if (importedDailyLastDay === progress.dailyPlayLastDay) {
      progress.dailyPlayStreak = Math.max(progress.dailyPlayStreak, importedDailyStreak);
    }
    raiseProgressCounter("statsButtonPressCount", packed[14]);
    raiseProgressCounter("totalDeathCount", packed[15]);
    raiseProgressCounter("manualTarinaiAddedCount", packed[16]);
    if (version >= 10 && mysteryDrugIds.length) {
      progress.mysteryDrugTarinaiIds = [...new Set([...(progress.mysteryDrugTarinaiIds || []), ...mysteryDrugIds])].slice(0, MAD_SCIENTIST_TARGET);
    }
    raiseProgressCounter("directFeedCount", packed[18]);
    raiseProgressCounter("robotCleanCount", packed[19]);
    const progressChanged = previousProgress !== JSON.stringify({ progress, ledger: ensureProgressLedger() });
    if (progressChanged) markProgressMutation();
    changed = changed || progressChanged;

    if (!state.unlocked[COMPLETIONIST_ID] && allOtherAchievementsUnlocked()) {
      const latestImportedAt = importedUnlocks.reduce((latest, entry) => Math.max(latest, Number(entry[1]) || 0), 0);
      state.unlocked[COMPLETIONIST_ID] = importedCompletionistAt || latestImportedAt || Date.now();
      queuePending(COMPLETIONIST_ID);
      unlockedAdded += 1;
      changed = true;
    }

    if (changed) {
      saveState();
      lastListSignature = "";
      render({ forceList: true });
      if (!DEBUG_MODE && unlockedAdded > 0) schedulePendingSync();
    }
    return { included: true, unlockedAdded, progressChanged };
  }

  function recordPlayerPlacement(detail = {}) {
    const world = detailWorld(detail);
    if (world) recordIntervention({ ...detail, world, tool: detail.tool || "placement" });
    if (!world) return false;
    recordIntervention({ ...detail, world });
    const item = detail.item || null;
    if (item) {
      if (!item._achievementPlayerPlaced || item._achievementPlayerPlacedCounted === false) world.achievementPlayerPlacedActiveCount = Math.max(0, Number(world.achievementPlayerPlacedActiveCount || 0) || 0) + 1;
      item._achievementPlayerPlaced = true;
      item._achievementPlayerPlacedCounted = true;
      item._achievementPlacedAt = Math.max(0, Number(world.time || 0) || 0);
    }
    let changed = evaluateCleanFreak(world, detail);
    changed = evaluateMegalopolis(world, detail) || changed;
    changed = evaluateSandbox(world, detail) || changed;
    if (!state.unlocked.placed_objects_100) {
      const count = incrementProgressCounter("placementCount");
      saveState();
      renderIfDialogOpen();
      if (count >= ADDITIVE_PROGRESS_CAPS.placementCount) changed = unlock("placed_objects_100", { ...detail, world, count }) || changed;
    }
    return changed;
  }

  function recordPlayerDeletion(detail = {}) {
    const world = detailWorld(detail);
    const item = detail.item || null;
    if (!world || !item) return false;
    let changed = evaluateCleanFreak(world, detail);
    changed = evaluateMegalopolis(world, detail) || changed;
    if (!item._achievementPlayerPlaced) return changed;
    const now = Math.max(0, Number(world.time || 0) || 0);
    const placedAtRaw = item._achievementPlacedAt;
    const placedAt = placedAtRaw == null ? NaN : Number(placedAtRaw);
    if (!Number.isFinite(placedAt) || now < placedAt || now - placedAt > 30.0001) return changed;
    if (!state.unlocked.unplanned_city_30) {
      const operationKey = detail.operationId == null ? "" : String(detail.operationId);
      if (operationKey && world._achievementLastQuickDeleteOperation === operationKey) return changed;
      if (operationKey) world._achievementLastQuickDeleteOperation = operationKey;
      const count = incrementProgressCounter("quickDeleteCount");
      saveState();
      renderIfDialogOpen();
      if (count >= ADDITIVE_PROGRESS_CAPS.quickDeleteCount) changed = unlock("unplanned_city_30", { ...detail, world, count }) || changed;
    }
    return changed;
  }

  function recordHistoryAction(kind, detail = {}) {
    const action = String(kind || detail.kind || "");
    if (action !== "undo" && action !== "redo") return false;
    const world = detailWorld(detail);
    if (world) recordIntervention({ ...detail, world, tool: action });
    const key = action === "undo" ? "undoCount" : "redoCount";
    const achievementId = action === "undo" ? "undo_20" : "redo_20";
    const count = incrementProgressCounter(key);
    saveState();
    renderIfDialogOpen();
    let changed = false;
    if (action === "undo" && Math.max(0, Number(detail.deadRestored || 0) || 0) >= 10) {
      changed = unlock("undo_mass_revival", { ...detail, count: Math.max(0, Number(detail.deadRestored || 0) || 0) }) || changed;
    }
    if (count >= ADDITIVE_PROGRESS_CAPS[key]) changed = unlock(achievementId, { ...detail, count }) || changed;
    return changed;
  }

  function mechanizedIndustryHasAllLinks(world = global.world) {
    if (!world) return false;
    return ["rope", "rod", "spring"].every(required => {
      const bucket = world.itemsOfType?.(required);
      if (Array.isArray(bucket)) return bucket.some(item => item && !item.dead);
      return (world.items || []).some(item => item && !item.dead && item.type === required);
    });
  }

  function evaluateMechanizedIndustry(detail = {}) {
    if (state.unlocked.mechanized_industry) return false;
    const world = detailWorld(detail);
    const source = detail.source || null;
    const detectorDriven = Boolean(detail.detectorDriven)
      || source?.type === "pressure_switch"
      || (Array.isArray(detail.detectorSources) && detail.detectorSources.some(candidate => candidate?.type === "pressure_switch"));
    const connectedTarget = Boolean(detail.connected) && detail.target && !detail.target.dead;
    if (world && detectorDriven && connectedTarget && mechanizedIndustryHasAllLinks(world)) {
      return unlock("mechanized_industry", { ...detail, world });
    }
    return false;
  }

  function recordLinkPlaced(type, detail = {}) {
    const linkType = String(type || detail.type || detail.item?.type || "");
    const placementLinkTypes = ["rope", "rod", "spring", "wire", "insulated_wire"];
    if (!placementLinkTypes.includes(linkType)) return false;
    return recordPlayerPlacement(detail);
  }

  function recordSignalActivation(detail = {}) {
    return evaluateMechanizedIndustry(detail);
  }

  function recordAntPopulation(worldRef = global.world) {
    if (!worldRef || state.unlocked.ants_alive_25) return false;
    const aliveAnts = (worldRef.ants || []).reduce((count, ant) => count + (ant && !ant.dead ? 1 : 0), 0);
    if (aliveAnts >= 25) return unlock("ants_alive_25", { world: worldRef, count: aliveAnts });
    return false;
  }

  function evaluateAntNestWithoutTarinai(worldRef = global.world, detail = {}) {
    if (!worldRef || state.unlocked.ant_nest_without_tarinai) return false;
    const hasNest = playstyleItemCount(worldRef, "ant_nest") > 0;
    if (!hasNest) return false;
    const aliveTarinai = (worldRef.tarinai || []).some(tarinai => tarinai && !tarinai.dead);
    if (aliveTarinai) return false;
    return unlock("ant_nest_without_tarinai", { ...detail, world: worldRef });
  }

  function recordStickyBombPass(item = null, detail = {}) {
    if (!item || item.dead || item.type !== "sticky_bomb" || state.unlocked.sticky_bomb_15_passes) return false;
    item.stickyBombPassCount = Math.max(0, Math.floor(Number(item.stickyBombPassCount || 0) || 0)) + 1;
    if (item.stickyBombPassCount < 15) return false;
    return unlock("sticky_bomb_15_passes", { ...detail, item, count: item.stickyBombPassCount });
  }

  function recordCircuitBoardSignalTransfer(sourceBoard = null, targetBoard = null, wire = null, detail = {}) {
    if (state.unlocked.information_industry) return false;
    if (!sourceBoard || !targetBoard || sourceBoard === targetBoard) return false;
    if (sourceBoard.type !== "circuit_board" || targetBoard.type !== "circuit_board") return false;
    if (!wire || !["wire", "insulated_wire"].includes(wire.type) || !wire.signalActive) return false;
    return unlock("information_industry", { ...detail, sourceBoard, targetBoard, wire });
  }

  function recordWirePowerState(wire = null, active = false) {
    if (!wire || (typeof wire !== "object" && typeof wire !== "function")) return false;
    if (!active) return false;
    if (!wireShockTrackers.has(wire)) wireShockTrackers.set(wire, { targets: new WeakSet(), count: 0 });
    return true;
  }

  function recordWireShock(wire = null, target = null, detail = {}) {
    if (state.unlocked.wire_shock_7_tarinai || !wire || !target || wire.type !== "wire" || !wire.signalActive) return false;
    const world = detail.world || wire.world || target.world || global.world || null;
    if (!world || !(world.tarinai || []).includes(target) || target.dead) return false;
    recordWirePowerState(wire, true);
    const tracker = wireShockTrackers.get(wire);
    if (!tracker || tracker.targets.has(target)) return false;
    tracker.targets.add(target);
    tracker.count += 1;
    if (tracker.count < WIRE_SHOCK_TARGET) return false;
    return unlock("wire_shock_7_tarinai", { ...detail, world, wire, target, count: tracker.count });
  }

  function recordAntKilled(detail = {}) {
    let changed = false;
    const playerCaused = Boolean(detail.playerCaused || detail.ant?._achievementLastDamageSource?.danger);
    if (!state.unlocked.ants_killed_100 && playerCaused) {
      const count = incrementProgressCounter("antKills");
      saveState();
      renderIfDialogOpen();
      if (count >= ADDITIVE_PROGRESS_CAPS.antKills) changed = unlock("ants_killed_100", { ...detail, count }) || changed;
    }
    const world = detailWorld(detail);
    const ant = detail.ant || null;
    const now = Math.max(0, Number(world?.time || 0) || 0);
    const aliveCount = (world?.tarinai || []).reduce((count, candidate) => count + (candidate && !candidate.dead ? 1 : 0), 0);
    if (world && aliveCount < 30) world.achievementEnemyAntKills = 0;
    if (!state.unlocked.enemy_enemy_friend && world && ant?._achievementLastDamageSource?.danger && aliveCount >= 30) {
      world.achievementEnemyAntKills = Math.min(10, Math.max(0, Math.floor(Number(world.achievementEnemyAntKills || 0) || 0)) + 1);
      renderIfDialogOpen();
      if (world.achievementEnemyAntKills >= 10) changed = unlock("enemy_enemy_friend", { ...detail, world, count: world.achievementEnemyAntKills }) || changed;
    }
    return changed;
  }

  function dangerItemSource(source = null) {
    if (!source) return null;
    const configured = global.TarinaiItemToolMetadata?.TOOL_CATEGORIES
      ?.find?.(category => category?.id === "hazard")?.toolIds;
    const hazardTypes = new Set(Array.isArray(configured)
      ? configured
      : ["stone", "genkotsu", "firecracker", "flame_firecracker", "sticky_bomb", "pushpin", "oshibyo", "shoot", "ant_nest"]);
    if (source.type && hazardTypes.has(String(source.type))) return source;
    const inherited = source._achievementDangerSource || null;
    return inherited?.type && hazardTypes.has(String(inherited.type)) ? inherited : null;
  }

  function recordDamageSource(tarinai, source = null, detail = {}) {
    if (!tarinai) return false;
    const world = detail.world || tarinai.world || global.world || null;
    const now = Math.max(0, Number(world?.time || 0) || 0);
    const dangerSource = dangerItemSource(source);
    // "Unharmed" means no actual damage from any cause while the streak is active.
    if (world) {
      if (Math.max(0, Math.floor(Number(world.achievementEnemyAntKills || 0) || 0)) > 0) {
        world.achievementEnemyAntKills = 0;
        renderIfDialogOpen();
      }
    }
    tarinai._achievementLastDamageSource = dangerSource ? {
      danger: true,
      at: now,
      itemId: String(dangerSource.id || ""),
      itemType: String(dangerSource.type || ""),
    } : { danger: false, at: now, itemId: "", itemType: "" };
    return Boolean(dangerSource);
  }

  function recordAntDamageSource(ant, source = null, detail = {}) {
    if (!ant) return false;
    const world = detail.world || ant.world || global.world || null;
    const now = Math.max(0, Number(world?.time || 0) || 0);
    const dangerSource = dangerItemSource(source);
    ant._achievementLastDamageSource = dangerSource ? {
      danger: true,
      at: now,
      itemId: String(dangerSource.id || ""),
      itemType: String(dangerSource.type || ""),
    } : { danger: false, at: now, itemId: "", itemType: "" };
    return Boolean(dangerSource);
  }

  function fightPairTracker(world) {
    if (!world || (typeof world !== "object" && typeof world !== "function")) return null;
    let tracker = dangerFightDeathsByWorld.get(world);
    if (!tracker) {
      tracker = new Map();
      dangerFightDeathsByWorld.set(world, tracker);
    }
    return tracker;
  }

  function recordFightPairDangerDeath(detail = {}) {
    if (state.unlocked.fight_pair_danger_kill) return false;
    const tarinai = detail.tarinai || null;
    const world = detail.world || tarinai?.world || null;
    if (!tarinai || !world) return false;
    const now = Math.max(0, Number(world.time || 0) || 0);
    const source = tarinai._achievementLastDamageSource || null;
    const lethalDanger = Boolean(detail.fromDamage || detail.achievementDangerKill);
    const session = tarinai._achievementFightSession || null;
    if (!lethalDanger || !source?.danger || Math.abs(now - Number(source.at || 0)) > 0.05) return false;
    if (!session?.id || !session.opponentId || Number(tarinai.fightTimer || 0) <= 0.04) return false;
    const tracker = fightPairTracker(world);
    if (!tracker) return false;
    const maxGap = 6;
    for (const [key, pending] of [...tracker.entries()]) {
      if (!pending || now - Number(pending.at || 0) > maxGap) {
        tracker.delete(key);
        continue;
      }
      if (pending.sessionId === session.id
        && pending.firstId !== tarinai.id
        && pending.otherId === tarinai.id
        && session.opponentId === pending.firstId) {
        tracker.delete(key);
        return unlock("fight_pair_danger_kill", { ...detail, pairKey: key, fightSessionId: session.id, first: pending, secondSource: source });
      }
    }
    const opponent = (world.tarinai || []).find(candidate => candidate && candidate.id === session.opponentId) || null;
    if (!opponent || opponent === tarinai || opponent.dead) return false;
    const opponentSession = opponent._achievementFightSession || null;
    if (opponentSession?.id !== session.id || opponentSession.opponentId !== tarinai.id) return false;
    const key = String(session.pairKey || world.fightPairKey?.(tarinai, opponent) || "");
    if (!key) return false;
    tracker.set(key, {
      firstId: tarinai.id,
      otherId: opponent.id,
      at: now,
      source,
      sessionId: session.id,
    });
    return false;
  }

  function recordSaveSlotsFilled(detail = {}) {
    if (state.unlocked.secret_collection_9_slots) return false;
    const storage = global.TarinaiSaveStorage;
    const slotCount = Math.max(0, Math.floor(Number(storage?.SLOT_COUNT || 9) || 9));
    let filled = Number(detail.filled);
    if (!Number.isFinite(filled)) {
      filled = 0;
      for (let slot = 1; slot <= slotCount; slot += 1) {
        try { if (storage?.readSlot?.(slot)?.hash) filled += 1; } catch (_) {}
      }
    }
    if (slotCount >= 9 && filled >= 9) return unlock("secret_collection_9_slots", { ...detail, filled, slotCount });
    return false;
  }

  function recordEmptyClick(detail = {}) {
    const world = detailWorld(detail);
    if (world) recordIntervention({ ...detail, world, tool: "empty_click" });
    if (state.unlocked.pause_spam_4_in_1_second) return false;
    const now = Number(detail.now);
    const timestamp = Number.isFinite(now) ? now : Date.now();
    emptyClickTimes = emptyClickTimes.filter(value => timestamp - value <= 1000 && timestamp >= value);
    emptyClickTimes.push(timestamp);
    if (emptyClickTimes.length >= 4) {
      emptyClickTimes = [];
      return unlock("pause_spam_4_in_1_second", { ...detail, count: 4, windowMs: 1000 });
    }
    return false;
  }

  function recordGroundChange(detail = {}) {
    const world = detailWorld(detail);
    const previous = String(detail.previous || "");
    const next = String(detail.next || world?.groundType || "");
    if (!world || detail.silent || !previous || !next || previous === next) return false;
    recordIntervention({ ...detail, world, tool: "ground_change" });
    let changed = false;
    if (!state.unlocked.park_ground_changed && String(world.fieldType || "") === "park") {
      changed = unlock("park_ground_changed", { ...detail, world, previous, next }) || changed;
    }
    if (!state.unlocked.ground_change_4_in_1_second) {
      const now = Number(detail.now);
      const timestamp = Number.isFinite(now) ? now : Date.now();
      groundChangeTimes = groundChangeTimes.filter(value => timestamp - value <= 1000 && timestamp >= value);
      groundChangeTimes.push(timestamp);
      if (groundChangeTimes.length >= 4) {
        groundChangeTimes = [];
        changed = unlock("ground_change_4_in_1_second", { ...detail, world, count: 4, windowMs: 1000 }) || changed;
      }
    }
    return changed;
  }

  function evaluateSandbox(world = global.world, detail = {}) {
    if (!world || state.unlocked.sandbox_five_toilets) return false;
    const count = playstyleItemCount(world, "toilet");
    if (count < 5) return false;
    return unlock("sandbox_five_toilets", { ...detail, world, count });
  }

  function recordLowFps(detail = {}) {
    if (state.unlocked.low_fps_single_digit) return false;
    const fps = Number.isFinite(Number(detail.fps)) ? Number(detail.fps) : Number(global.__tarinaiFps);
    if (!Number.isFinite(fps) || fps <= 0 || fps >= 10) return false;
    return unlock("low_fps_single_digit", { ...detail, fps });
  }

  function localDayNumber(value = Date.now()) {
    const date = new Date(Number(value));
    if (!Number.isFinite(date.getTime())) return 0;
    return Math.floor(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()) / DAY_MS);
  }

  function recordDailyPlay(detail = {}) {
    if (state.unlocked.daily_play_7_days) return false;
    const today = localDayNumber(Number.isFinite(Number(detail.now)) ? Number(detail.now) : Date.now());
    if (!today) return false;
    const progress = ensureProgress();
    const previousDay = progress.dailyPlayLastDay;
    if (today < previousDay || today === previousDay) return false;
    progress.dailyPlayStreak = today === previousDay + 1
      ? Math.min(DAILY_PLAY_TARGET, progress.dailyPlayStreak + 1)
      : 1;
    progress.dailyPlayLastDay = today;
    markProgressMutation();
    saveState();
    renderIfDialogOpen();
    if (progress.dailyPlayStreak >= DAILY_PLAY_TARGET) {
      return unlock("daily_play_7_days", { ...detail, day: today, streak: progress.dailyPlayStreak });
    }
    return false;
  }

  function recordContinuousPlay(detail = {}) {
    if (state.unlocked.continuous_play_1_hour && state.unlocked.continuous_play_24_hours) return false;
    const explicitElapsed = Number(detail.elapsedMs);
    let elapsedMs;
    if (Number.isFinite(explicitElapsed)) {
      elapsedMs = Math.max(0, explicitElapsed);
    } else {
      const timestamp = Number.isFinite(Number(detail.now)) ? Number(detail.now) : Date.now();
      elapsedMs = continuousPlayElapsedMs(timestamp);
    }
    let changed = false;
    if (!state.unlocked.continuous_play_1_hour && elapsedMs >= CONTINUOUS_PLAY_TARGET_MS) {
      changed = unlock("continuous_play_1_hour", { ...detail, elapsedMs }) || changed;
    }
    if (!state.unlocked.continuous_play_24_hours && elapsedMs >= CONTINUOUS_PLAY_24H_TARGET_MS) {
      changed = unlock("continuous_play_24_hours", { ...detail, elapsedMs }) || changed;
    }
    return changed;
  }

  function recordBelowAbsoluteZeroItem(worldRef = global.world, detail = {}) {
    if (state.unlocked.below_absolute_zero_item || !worldRef) return false;
    worldRef.ensureItemBuckets?.("achievement-absolute-zero");
    const testItem = (item) => {
      if (!item || item.dead) return false;
      const temperature = Number(worldRef.temperatureAt?.(item.x, item.y, null));
      if (!Number.isFinite(temperature) || temperature >= ABSOLUTE_ZERO_C) return false;
      return unlock("below_absolute_zero_item", { ...detail, world: worldRef, item, temperature });
    };
    // Evaluate the actual temperature field for every live item. This avoids
    // coupling the achievement to a hard-coded list of present-day heat sources.
    for (const item of worldRef.items || []) {
      if (testItem(item)) return true;
    }
    for (const residue of worldRef.residues || []) {
      if (testItem(residue)) return true;
    }
    return false;
  }

  function importWorldAchievementProgress(detail = {}) {
    const imported = Math.min(ROBOT_CLEAN_TARGET, Math.max(0, Math.floor(Number(detail.robotCleanCount || 0) || 0)));
    const current = progressCounter("robotCleanCount");
    if (imported <= current) return false;
    raiseProgressCounter("robotCleanCount", imported);
    saveState();
    renderIfDialogOpen();
    return true;
  }

  function recordRobotClean(detail = {}) {
    if (state.unlocked.robot_cleaner_100) return false;
    const world = detailWorld(detail);
    const type = String(detail.type || detail.target?.type || "");
    if (!world || !["zunchi", "ant_corpse", "trace", "splat"].includes(type)) return false;
    const count = incrementProgressCounter("robotCleanCount");
    if (count >= ROBOT_CLEAN_TARGET) return unlock("robot_cleaner_100", { ...detail, world, count });
    saveState();
    renderIfDialogOpen();
    return false;
  }

  function robotCleanerIsRunning(robot) {
    if (!robot || robot.dead || robot.type !== "robot_cleaner") return false;
    return !robot._signalDriven || Boolean(robot._signalOn);
  }

  function evaluateCleanFreak(world = global.world, detail = {}) {
    if (!world || state.unlocked.clean_freak_robot_only) return false;
    const activeObjects = Math.max(0, Number(world.activeObjectCount?.() ?? (world.items || []).reduce((count, item) => count + (item && !item.dead ? 1 : 0), 0)) || 0);
    const robotCount = Math.max(0, Number(world.itemCounts?.robot_cleaner || 0) || 0);
    if (!activeObjects || robotCount !== activeObjects) return false;
    const liveItems = world.itemsOfType?.("robot_cleaner") || [];
    if ((world.tarinai || []).some(tarinai => tarinai && !tarinai.dead)) return false;
    if ((world.ants || []).some(ant => ant && !ant.dead)) return false;
    if ((world.residues || []).some(residue => residue && !residue.dead && Math.max(0, Number(residue.amount ?? 1) || 0) > 0)) return false;
    const qualifies = liveItems.some(robot => {
      const mask = Number(global.TarinaiItemDynamicToolSystem?.robotCleanerMask?.(robot) ?? robot.robotCleanerMask ?? 0) | 0;
      return (mask & ROBOT_ALL_TARGET_MASK) === ROBOT_ALL_TARGET_MASK
        && Boolean(global.TarinaiItemDynamicToolSystem?.robotCleanerHighSpeed?.(robot) ?? robot.robotCleanerHighSpeed)
        && robotCleanerIsRunning(robot);
    });
    if (!qualifies) return false;
    return unlock("clean_freak_robot_only", { ...detail, world, robotCount: liveItems.length });
  }

  function evaluateStatusEffectAchievements(tarinai, detail = {}) {
    if (!tarinai || tarinai.dead) return false;
    let changed = false;
    if (!state.unlocked.king_full_satisfaction
      && tarinai.isTarinaiChampion
      && tarinai.powerItemMode === "protein"
      && tarinai.sizeItemMode === "giant_drug") {
      changed = unlock("king_full_satisfaction", { ...detail, tarinai, world: detail.world || tarinai.world || null }) || changed;
    }
    if (!state.unlocked.slave_zero_satisfaction
      && tarinai.isZunchiSlave
      && tarinai.powerItemMode === "niteropu"
      && tarinai.sizeItemMode === "dwarf_drug") {
      changed = unlock("slave_zero_satisfaction", { ...detail, tarinai, world: detail.world || tarinai.world || null }) || changed;
    }
    return changed;
  }

  function recordFirstAidRecovery(detail = {}) {
    if (state.unlocked.town_doctor_50) return false;
    const recovered = Number(detail.recovered ?? detail.amount ?? 0);
    if (!Number.isFinite(recovered) || recovered <= 0.0001) return false;
    const count = incrementProgressCounter("firstAidHeals");
    saveState();
    renderIfDialogOpen();
    if (count >= ADDITIVE_PROGRESS_CAPS.firstAidHeals) return unlock("town_doctor_50", { ...detail, count, recovered });
    return false;
  }

  function recordPlushiePokeFling(detail = {}) {
    return unlock("poke_plushie_fling", detail);
  }

  function recordConsumableUse(detail = {}) {
    const type = String(detail.type || detail.item?.type || "");
    const tarinai = detail.tarinai || null;
    const world = detailWorld(detail);
    let changed = false;
    if (type === "fight_mochi" && tarinai && world) {
      tarinai._achievementFightMochiAt = Math.max(0, Number(world.time || 0) || 0);
      tarinai._achievementFightMochiWorld = world;
    }
    if (type === "mystery_drug" && tarinai && !state.unlocked.mad_scientist) {
      const progress = ensureProgress();
      const identity = String(tarinai.familyKey || tarinai.id || "");
      if (identity && !progress.mysteryDrugTarinaiIds.includes(identity)) {
        progress.mysteryDrugTarinaiIds = [...progress.mysteryDrugTarinaiIds, identity].slice(0, MAD_SCIENTIST_TARGET);
        markProgressMutation();
        if (progress.mysteryDrugTarinaiIds.length >= MAD_SCIENTIST_TARGET) {
          changed = unlock("mad_scientist", { ...detail, world, tarinai, count: progress.mysteryDrugTarinaiIds.length }) || changed;
        } else {
          saveState();
          renderIfDialogOpen();
        }
      }
    }
    if (MEDICINE_LEDGER_TYPES.includes(type) && !state.unlocked.medicine_ledger_all) {
      const progress = ensureProgress();
      if (!progress.medicineTypes.includes(type)) {
        progress.medicineTypes = [...progress.medicineTypes, type];
        markProgressMutation();
        saveState();
        renderIfDialogOpen();
      }
      if (MEDICINE_LEDGER_TYPES.every(required => progress.medicineTypes.includes(required))) {
        changed = unlock("medicine_ledger_all", { ...detail, count: progress.medicineTypes.length }) || changed;
      }
    }
    changed = evaluateStatusEffectAchievements(tarinai, { ...detail, world }) || changed;
    return changed;
  }

  function recordDirectCare(detail = {}) {
    const world = detailWorld(detail);
    if (world) recordIntervention({ ...detail, world, tool: "direct_care" });
    const tarinai = detail.tarinai || null;
    const type = String(detail.type || detail.item?.type || "");
    if (!world || !tarinai) return false;
    const foodGift = Boolean(detail.foodGift);
    const treatment = Boolean(detail.beneficialRecovery);
    if (foodGift) {
      tarinai._achievementDirectFeedCount = Math.max(0, Math.floor(Number(tarinai._achievementDirectFeedCount || 0) || 0)) + 1;
      world.achievementSelfSufficientStartAt = -1;
    }
    if (treatment) tarinai._achievementDirectTreatmentCount = Math.max(0, Math.floor(Number(tarinai._achievementDirectTreatmentCount || 0) || 0)) + 1;
    recordConsumableUse({ ...detail, world, tarinai, type });
    if (tarinai._achievementDirectFeedCount >= 10 && tarinai._achievementDirectTreatmentCount >= 3) {
      return unlock("overprotective", { ...detail, world, tarinai, feedCount: tarinai._achievementDirectFeedCount, treatmentCount: tarinai._achievementDirectTreatmentCount });
    }
    return false;
  }

  function recordFightStarted(detail = {}) {
    const world = detailWorld(detail);
    if (!world) return false;
    let changed = false;
    const fightMochiInfluenced = [detail.a, detail.b].some(tarinai => Boolean(tarinai) && (
      (Number(tarinai.fightMochiTimer || 0) > 0.04) || Boolean(tarinai.hasFightMochiEffect?.())
    ));
    if (!state.unlocked.chaos_seeker_666_fights && fightMochiInfluenced) {
      const count = incrementProgressCounter("fightMochiFightCount");
      if (count >= CHAOS_FIGHT_TARGET) {
        changed = unlock("chaos_seeker_666_fights", { ...detail, world, count, fightMochiInfluenced: true }) || changed;
      } else {
        saveState();
        renderIfDialogOpen();
      }
    }
    const now = Math.max(0, Number(world.time || 0) || 0);
    const pairA = detail.a || null;
    const pairB = detail.b || null;
    if (pairA && pairB && pairA !== pairB) {
      world.achievementFightSessionSerial = Math.max(0, Math.floor(Number(world.achievementFightSessionSerial || 0) || 0)) + 1;
      const pairKey = world.fightPairKey?.(pairA, pairB)
        || [String(pairA.id || ""), String(pairB.id || "")].sort().join(":");
      const sessionId = `${pairKey}@${world.achievementFightSessionSerial}`;
      pairA._achievementFightSession = { id: sessionId, pairKey, opponentId: pairB.id, startedAt: now };
      pairB._achievementFightSession = { id: sessionId, pairKey, opponentId: pairA.id, startedAt: now };
    }
    const candidates = [detail.a, detail.b].filter(Boolean);
    for (const tarinai of candidates) {
      const givenAtRaw = tarinai._achievementFightMochiAt;
      const givenAt = givenAtRaw == null ? NaN : Number(givenAtRaw);
      const validCurrentSessionMochi = tarinai._achievementFightMochiWorld === world;
      if (validCurrentSessionMochi && Number.isFinite(givenAt) && now >= givenAt && now - givenAt <= 30.0001) {
        changed = unlock("fuel_to_fire", { ...detail, world, tarinai, elapsed: now - givenAt }) || changed;
        break;
      }
    }
    return changed;
  }

  function recordShotFired(detail = {}) {
    if (state.unlocked.sniper_333_shots) return false;
    const count = incrementProgressCounter("shotCount");
    if (count >= SNIPER_SHOT_TARGET) return unlock("sniper_333_shots", { ...detail, count });
    saveState();
    renderIfDialogOpen();
    return false;
  }

  function recordLoveMochiBirth(detail = {}) {
    if (state.unlocked.fertility_seeker_721_love_births || !detail.loveMochiInfluenced) return false;
    const count = incrementProgressCounter("loveMochiBirthCount");
    if (count >= FERTILITY_BIRTH_TARGET) {
      return unlock("fertility_seeker_721_love_births", { ...detail, count });
    }
    saveState();
    renderIfDialogOpen();
    return false;
  }

  function evaluateMegalopolis(world = global.world, detail = {}) {
    if (!world || state.unlocked.megalopolis) return false;
    const aliveCount = playstylePopulationCount(world);
    if (aliveCount < 100) return false;
    const duplicatorCount = playstyleItemCount(world, "duplicator");
    const shelterCount = playstyleItemCount(world, "grass_bed")
      + playstyleItemCount(world, "nest_box")
      + playstyleItemCount(world, "pipe");
    if (duplicatorCount < 10 || shelterCount < 15) return false;
    return unlock("megalopolis", { ...detail, world, aliveCount, duplicatorCount, shelterCount });
  }

  function resetWorldProgress(world = global.world) {
    if (!world) return false;
    runtimeByWorld.delete(world);
    dangerFightDeathsByWorld.delete(world);
    world.achievementEnemyAntKills = 0;
    world.achievementSelfSufficientStartAt = -1;
    world.achievementNoDeathStartAt = -1;
    world.achievementHappyStartAt = -1;
    world.achievementEliteFewStartAt = -1;
    for (const tarinai of world.tarinai || []) {
      if (!tarinai) continue;
      tarinai._achievementFightMochiAt = null;
      tarinai._achievementFightMochiWorld = null;
      tarinai._achievementDirectFeedCount = 0;
      tarinai._achievementDirectTreatmentCount = 0;
      tarinai._achievementSaunaHotAt = null;
      tarinai._achievementSaunaWasHot = false;
      tarinai._achievementHeldStartedAt = null;
      tarinai._achievementFightSession = null;
    }
    for (const item of world.items || []) {
      if (!item) continue;
      if (item.type === "sticky_bomb") item.stickyBombPassCount = 0;
      item._achievementPlacedAt = null;
    }
    // Mystery-drug targets are a lifetime achievement and intentionally survive world resets.
    return true;
  }

  function recordHeldTarinai(world = global.world, now = Date.now()) {
    if (!world || state.unlocked.held_30_seconds) return false;
    if (document.hidden) {
      for (const tarinai of world.tarinai || []) {
        if (tarinai) tarinai._achievementHeldStartedAt = null;
      }
      return false;
    }
    const timestamp = Number(now);
    if (!Number.isFinite(timestamp)) return false;
    for (const tarinai of world.tarinai || []) {
      if (!tarinai || tarinai.dead) continue;
      if (tarinai.playerHeld || tarinai._heldByPlayer) {
        if (tarinai._achievementHeldStartedAt == null || !Number.isFinite(Number(tarinai._achievementHeldStartedAt))) tarinai._achievementHeldStartedAt = timestamp;
        if (timestamp >= tarinai._achievementHeldStartedAt && timestamp - tarinai._achievementHeldStartedAt >= HELD_TARGET_MS) {
          return unlock("held_30_seconds", { world, tarinai, elapsedMs: timestamp - tarinai._achievementHeldStartedAt });
        }
      } else {
        tarinai._achievementHeldStartedAt = null;
      }
    }
    return false;
  }

  function recordBirth(detail = {}) {
    unlock("first_birth", detail);
    const child = detail.child || null;
    const world = detail.world || child?.world || null;
    const generation = Math.max(1, Math.floor(Number(child?.generation || world?.maxGeneration || 1) || 1));
    if (generation >= GENERATION_TARGET) unlock("eternal_history_generation_10", { ...detail, world, child, generation });
    if (child?.isZunchiSlave) recordNaturalStatus("slave", { ...detail, world, tarinai: child, bornWithStatus: true });
    if (child?.isTarinaiChampion) recordNaturalStatus("king", { ...detail, world, tarinai: child, bornWithStatus: true });
    evaluateMegalopolis(world, detail);
    if (!state.unlocked.great_mother_1000_births) {
      const count = incrementProgressCounter("birthCount");
      saveState();
      renderIfDialogOpen();
      if (count >= ADDITIVE_PROGRESS_CAPS.birthCount) unlock("great_mother_1000_births", { ...detail, count });
    }
    if (state.unlocked.birth_50_in_60_seconds) return;
    const now = Number(world?.time || 0) || 0;
    const tracker = runtimeTracker(world, now);
    if (!tracker) return;
    tracker.birthTimes.push(now);
    tracker.birthTimes = tracker.birthTimes.filter(time => time >= now - 60.0001);
    if (tracker.birthTimes.length >= 30) unlock("birth_50_in_60_seconds", detail);
  }

  function recordDeath(detail = {}) {
    recordFightPairDangerDeath(detail);
    if (!state.unlocked.memento_mori) {
      const count = incrementProgressCounter("totalDeathCount");
      if (count >= MEMENTO_MORI_TARGET) unlock("memento_mori", { ...detail, count });
      else { scheduleProgressSave(); renderIfDialogOpen(); }
    }
    const reason = String(detail.reason || detail.tarinai?.deathReason || "");
    const lifespanDeath = /\u5bff\u547d|\u5929\u5bff/.test(reason);
    const world = detail.world || detail.tarinai?.world || null;
    if (world) {
      evaluateMegalopolis(world, detail);
      const aliveAfterDeath = playstylePopulationCount(world);
      if (!state.unlocked.enemy_enemy_friend && aliveAfterDeath < 30) world.achievementEnemyAntKills = 0;
      if (!lifespanDeath) {
        world.achievementNoDeathStartAt = aliveAfterDeath >= 25 ? Math.max(0, Number(world.time || 0) || 0) : -1;
      }
    }
    const now = Number(world?.time || 0) || 0;
    const tracker = runtimeTracker(world, now);
    if (tracker) {
      tracker.deathTimes.push(now);
      tracker.deathTimes = tracker.deathTimes.filter(time => time >= now - 10.0001);
      if (tracker.deathTimes.length >= 50) unlock("death_50_in_10_seconds", detail);
    }
    const tarinai = detail.tarinai || null;
    if (reason.includes("\u5929\u5bff\u3092\u5168\u3046\u3057\u305f")) {
      unlock("lifespan_completed", detail);
      if (tarinai?.lifeItemMode === "mercury" || Number(tarinai?.mercuryLifeMultiplier || 0) > 1) unlock("mercury_lifespan", detail);
    }
    const attackerId = String(tarinai?._achievementLastFightAttackerId || "");
    const attackerAt = Number(tarinai?._achievementLastFightDamageAt);
    const attacker = attackerId ? (world?.tarinai || []).find(candidate => candidate && String(candidate.id || "") === attackerId) : null;
    if (tarinai?.isTarinaiChampion && attacker?.isZunchiSlave && reason.includes("\u55a7\u5629") && Number.isFinite(attackerAt) && Math.abs(now - attackerAt) <= 0.1) {
      unlock("revolution", { ...detail, attacker });
    }
    const laxativeActive = Boolean(tarinai?._achievementLaxativeActiveThisFrame || tarinai?.hasItemEffect?.("laxative") || Number(tarinai?.itemEffectTimers?.laxative || 0) > 0.04);
    if (laxativeActive && reason.includes("\u98e2\u9913")) unlock("laxative_starvation", detail);
  }

  function recordNaturalStatus(kind, detail = {}) {
    const tarinai = detail.tarinai || null;
    const world = detail.world || tarinai?.world || null;
    if (kind === "slave") {
      unlock("natural_zunchi_slave", detail);
      if (tarinai?.isAcquiredTarinai) unlock("ochibi_natural_slave", detail);
      if (recordNaturalGeneration(world, tarinai, "_achievementNaturalSlaveLineageDepth", 5)) {
        unlock("natural_zunchi_slave_5_generations", detail);
      }
      evaluateStatusEffectAchievements(tarinai, detail);
      return;
    }
    if (kind === "king") {
      unlock("natural_tarinai_king", detail);
      if (recordNaturalGeneration(world, tarinai, "_achievementNaturalKingLineageDepth", 3)) {
        unlock("natural_tarinai_king_3_generations", detail);
      }
      evaluateStatusEffectAchievements(tarinai, detail);
    }
  }

  function recordDirectFeed(detail = {}) {
    const world = detailWorld(detail);
    if (!world) return false;
    recordDirectCare({ ...detail, world, foodGift: true });
    if (state.unlocked.direct_feed_33) return false;
    const count = incrementProgressCounter("directFeedCount");
    saveState();
    renderIfDialogOpen();
    if (count >= ADDITIVE_PROGRESS_CAPS.directFeedCount) return unlock("direct_feed_33", { ...detail, world, count });
    return false;
  }

  function recordIgnition(detail = {}) {
    return unlock("ignite_during_birth_ritual", detail);
  }

  function recordFavoriteTarinai(detail = {}) {
    if (state.unlocked.favorite_one) return false;
    const tarinai = detail.tarinai || detail.target || null;
    if (!tarinai || tarinai.dead || !tarinai.favorite) return false;
    return unlock("favorite_one", detail);
  }

  function recordStatsButtonPress(detail = {}) {
    if (state.unlocked.statistician) return false;
    const count = incrementProgressCounter("statsButtonPressCount");
    if (count >= STATISTICIAN_TARGET) {
      return unlock("statistician", { ...detail, count });
    }
    saveState();
    renderIfDialogOpen();
    return false;
  }

  function recordPushNotificationsEnabled(detail = {}) {
    if (state.unlocked.well_informed) return false;
    return unlock("well_informed", detail);
  }

  function recordManualTarinaiAdded(detail = {}) {
    // Adding a Tarinai is a direct player intervention and must invalidate
    // the no-operation window used by the surveillance-camera achievement.
    recordIntervention({ ...detail, tool: detail.tool || "new-tarinai" });
    if (state.unlocked.lively_making) return false;
    const count = incrementProgressCounter("manualTarinaiAddedCount");
    if (count >= LIVELY_MAKING_TARGET) {
      return unlock("lively_making", { ...detail, count });
    }
    saveState();
    renderIfDialogOpen();
    return false;
  }

  function playstylePopulationCount(worldRef) {
    const cached = worldRef?.tarinaiCounts?.();
    if (cached && Number.isFinite(Number(cached.alive))) return Math.max(0, Number(cached.alive) || 0);
    return (worldRef?.tarinai || []).reduce((count, tarinai) => count + (tarinai && !tarinai.dead ? 1 : 0), 0);
  }

  function playstyleItemCount(worldRef, type) {
    const counts = worldRef?.itemCounts;
    if (counts && typeof counts === "object") return Math.max(0, Number(counts[type] || 0) || 0);
    let count = 0;
    for (const item of worldRef?.items || []) if (item && !item.dead && item.type === type) count += 1;
    return count;
  }

  function playstyleBedCapacity(worldRef) {
    return playstyleItemCount(worldRef, "bed")
      + playstyleItemCount(worldRef, "grass_bed")
      + playstyleItemCount(worldRef, "nest_box") * 5
      + playstyleItemCount(worldRef, "pipe") * 3;
  }

  function evaluateEvent(worldRef, trigger = "timer", detail = {}) {
    if (!worldRef) return false;
    const kind = String(trigger || "timer");
    const populationEvent = kind === "population" || kind === "timer" || kind === "season" || kind === "restore";
    const itemEvent = kind === "items" || populationEvent;
    const now = Math.max(0, Number(worldRef.time || 0) || 0);
    const aliveCount = populationEvent || itemEvent ? playstylePopulationCount(worldRef) : 0;
    let changed = false;

    if (populationEvent) {
      if (!state.unlocked.strength_in_numbers && aliveCount >= STRENGTH_IN_NUMBERS_TARGET) {
        changed = unlock("strength_in_numbers", { ...detail, world: worldRef, count: aliveCount }) || changed;
      }
      if (!state.unlocked.elite_few) {
        if (aliveCount > 0 && aliveCount <= ELITE_FEW_MAX_POPULATION) {
          let startedAt = Number(worldRef.achievementEliteFewStartAt);
          if (!Number.isFinite(startedAt) || startedAt < 0 || startedAt > now) {
            startedAt = now;
            worldRef.achievementEliteFewStartAt = now;
          }
          const dayLength = Math.max(1, Number(worldRef.config?.dayLength ?? global.CONFIG?.dayLength ?? 120) || 120);
          const targetDuration = dayLength * ELITE_FEW_TARGET_DAYS;
          if (now - startedAt >= targetDuration) {
            changed = unlock("elite_few", { ...detail, world: worldRef, count: aliveCount, elapsed: now - startedAt, days: ELITE_FEW_TARGET_DAYS }) || changed;
          }
        } else {
          worldRef.achievementEliteFewStartAt = -1;
        }
      }
      changed = evaluateMegalopolis(worldRef, detail) || changed;
    }

    if (itemEvent) {
      const zunchiCount = playstyleItemCount(worldRef, "zunchi");
      const bedCapacity = playstyleBedCapacity(worldRef);
      if (!state.unlocked.zunchi_overflow && aliveCount >= 20 && zunchiCount > aliveCount) {
        changed = unlock("zunchi_overflow", { ...detail, world: worldRef, aliveCount, zunchiCount }) || changed;
      }
      if (!state.unlocked.comfortable_beds && aliveCount > 0 && bedCapacity >= aliveCount) {
        changed = unlock("comfortable_beds", { ...detail, world: worldRef, aliveCount, bedCapacity }) || changed;
      }
      if (!state.unlocked.stone_pillow && aliveCount >= 30 && bedCapacity === 0) {
        changed = unlock("stone_pillow", { ...detail, world: worldRef, aliveCount, bedCapacity }) || changed;
      }
      changed = evaluateMegalopolis(worldRef, detail) || changed;
    }

    if ((kind === "season" || kind === "timer" || kind === "restore") && !state.unlocked.across_seasons) {
      const elapsedDays = Number.isFinite(Number(worldRef.elapsedDays))
        ? Math.max(0, Number(worldRef.elapsedDays) || 0)
        : Math.max(0, Math.floor(now / Math.max(1, Number(worldRef.config?.dayLength ?? global.CONFIG?.dayLength ?? 120) || 120)));
      if (elapsedDays >= FULL_SEASON_CYCLE_DAYS) changed = unlock("across_seasons", { ...detail, world: worldRef, elapsedDays }) || changed;
    }
    return changed;
  }

  function evaluateWorld(worldRef, mood = null) {
    if (!worldRef) return false;
    const maxGeneration = Math.max(1, Math.floor(Number(worldRef.maxGeneration || 1) || 1));
    if (!state.unlocked.eternal_history_generation_10 && maxGeneration >= GENERATION_TARGET) {
      unlock("eternal_history_generation_10", { world: worldRef, generation: maxGeneration });
    }
    evaluateEvent(worldRef, "timer", { mood });
    const needsAliveScan = !state.unlocked.all_non_sleep_diseased_25
      || !state.unlocked.colony_happy
      || !state.unlocked.minimalist_happy
      || !state.unlocked.self_sufficient
      || !state.unlocked.rain_shelter_all
      || !state.unlocked.sauna_cold_plunge
      || !state.unlocked.idle_observer_5_minutes
      || !state.unlocked.safe_colony_25_5_minutes
      || !state.unlocked.ant_nest_without_tarinai;
    const needsAntScan = !state.unlocked.ants_alive_25;
    const needsTemperatureItemScan = !state.unlocked.below_absolute_zero_item;
    const needsCleanFreakScan = !state.unlocked.clean_freak_robot_only;
    if (!needsAliveScan && !needsAntScan && !needsTemperatureItemScan && !needsCleanFreakScan) return true;
    const now = Math.max(0, Number(worldRef.time || 0) || 0);
    const alive = needsAliveScan ? (worldRef.tarinai || []).filter(t => t && !t.dead) : [];
    const aliveCount = alive.length;
    if (!state.unlocked.all_non_sleep_diseased_25
      && alive.length >= 25
      && alive.every(t => Boolean(t.zunchiDisease || t.explosionDisease || t.fightDisease))) {
      unlock("all_non_sleep_diseased_25", { world: worldRef, count: alive.length });
    }
    const moodId = String(mood?.id || worldRef.colonyMood?.id || "");
    const day = Math.max(1, Math.floor(Number(worldRef.day || 1) || 1));
    if (alive.length > 0 && moodId === "happy" && day >= 6 && !state.unlocked.minimalist_happy) {
      const placedAlive = Math.max(0, Number(worldRef.achievementPlayerPlacedActiveCount || 0) || 0);
      if (placedAlive <= 10) unlock("minimalist_happy", { world: worldRef, mood: mood || worldRef.colonyMood, placedAlive });
    }
    if (!state.unlocked.colony_happy) {
      if (alive.length > 0 && moodId === "happy" && day >= 6) {
        let happyStart = Number(worldRef.achievementHappyStartAt);
        if (!Number.isFinite(happyStart) || happyStart < 0 || happyStart > now) {
          happyStart = now;
          worldRef.achievementHappyStartAt = now;
        }
        const dayLength = Math.max(1, Number(global.CONFIG?.dayLength || 120) || 120);
        if (now - happyStart >= dayLength) unlock("colony_happy", { world: worldRef, mood: mood || worldRef.colonyMood, elapsed: now - happyStart, day });
      } else {
        worldRef.achievementHappyStartAt = -1;
      }
    }

    if (!state.unlocked.self_sufficient) {
      if (alive.length >= 20 && playstyleItemCount(worldRef, "duplicator") === 0) {
        let selfStart = Number(worldRef.achievementSelfSufficientStartAt);
        if (!Number.isFinite(selfStart) || selfStart < 0 || selfStart > now) {
          selfStart = now;
          worldRef.achievementSelfSufficientStartAt = now;
        }
        if (now - selfStart >= 600) unlock("self_sufficient", { world: worldRef, count: alive.length, elapsed: now - selfStart });
      } else {
        worldRef.achievementSelfSufficientStartAt = -1;
      }
    }

    if (!state.unlocked.rain_shelter_all
      && worldRef.weather === "light_rain"
      && alive.length >= 20
      && alive.every(tarinai => Boolean(global.TarinaiRainShelterSystem?.isSheltered?.(worldRef, tarinai.x, tarinai.y, tarinai)))) {
      unlock("rain_shelter_all", { world: worldRef, count: alive.length });
    }

    const needsSauna = !state.unlocked.sauna_cold_plunge;
    if (needsSauna) {
      for (const tarinai of alive) {
        const temperature = Number(worldRef.feltTemperatureFor?.(tarinai) ?? worldRef.temperatureAt?.(tarinai.x, tarinai.y, tarinai));
        const status = Number.isFinite(temperature) ? worldRef.temperatureStatusFor?.(temperature, tarinai) : null;
        const direction = String(status?.direction || "");
        const isHot = direction === "hot" && status?.comfortable !== true;
        const isCold = direction === "cold" && status?.comfortable !== true;
        let hotAt = tarinai._achievementSaunaHotAt == null ? NaN : Number(tarinai._achievementSaunaHotAt);
        let wasHot = tarinai._achievementSaunaWasHot;
        if (wasHot == null) wasHot = Boolean(isHot && Number.isFinite(hotAt));
        if (isHot) {
          if (!wasHot || !Number.isFinite(hotAt) || hotAt > now) {
            hotAt = now;
            tarinai._achievementSaunaHotAt = now;
          }
          tarinai._achievementSaunaWasHot = true;
        } else {
          tarinai._achievementSaunaWasHot = false;
          if (isCold && Number.isFinite(hotAt) && now >= hotAt && now - hotAt <= 15.0001) {
            unlock("sauna_cold_plunge", { world: worldRef, tarinai, elapsed: now - hotAt, temperature });
          }
          if (Number.isFinite(hotAt) && now - hotAt > 15.0001) tarinai._achievementSaunaHotAt = null;
        }
      }
    }

    if (!state.unlocked.idle_observer_5_minutes) {
      let lastInterventionAt = Number(worldRef.achievementLastInterventionAt);
      if (!Number.isFinite(lastInterventionAt) || lastInterventionAt < 0 || lastInterventionAt > now) {
        lastInterventionAt = now;
        worldRef.achievementLastInterventionAt = now;
      }
      const dayLength = Math.max(1, Number(worldRef.config?.dayLength ?? global.CONFIG?.dayLength ?? 120) || 120);
      const observerTarget = dayLength * OBSERVER_GAME_DAYS;
      if (now - lastInterventionAt >= observerTarget) unlock("idle_observer_5_minutes", { world: worldRef, elapsed: now - lastInterventionAt, gameDays: OBSERVER_GAME_DAYS });
    }

    if (!state.unlocked.safe_colony_25_5_minutes) {
      if (alive.length >= 25) {
        let safeStart = Number(worldRef.achievementNoDeathStartAt);
        if (!Number.isFinite(safeStart) || safeStart < 0 || safeStart > now) {
          safeStart = now;
          worldRef.achievementNoDeathStartAt = now;
        }
        if (now - safeStart >= 300) unlock("safe_colony_25_5_minutes", { world: worldRef, count: alive.length, elapsed: now - safeStart });
      } else {
        worldRef.achievementNoDeathStartAt = -1;
      }
    }

    if (!state.unlocked.sandbox_five_toilets) evaluateSandbox(worldRef, { source: "world-evaluation" });
    if (!state.unlocked.ants_alive_25) recordAntPopulation(worldRef);
    if (!state.unlocked.ant_nest_without_tarinai) evaluateAntNestWithoutTarinai(worldRef, { source: "world-evaluation" });
    if (!state.unlocked.below_absolute_zero_item) recordBelowAbsoluteZeroItem(worldRef);
    if (!state.unlocked.clean_freak_robot_only) evaluateCleanFreak(worldRef, { source: "world-evaluation" });
    if (!state.unlocked.megalopolis && alive.length >= 100) evaluateMegalopolis(worldRef, { source: "world-evaluation" });
    return true;
  }

  async function resetAchievements() {
    await persistenceReadyPromise;
    const confirmed = await global.TarinaiGameDialogs?.confirm?.({
      title: "\u5b9f\u7e3e\u306e\u30ea\u30bb\u30c3\u30c8",
      message: "\u3059\u3079\u3066\u306e\u5b9f\u7e3e\u89e3\u9664\u72b6\u614b\u3068\u3001\u5171\u6709\u96c6\u8a08\u4e0a\u306e\u81ea\u5206\u306e\u89e3\u9664\u8a18\u9332\u3092\u524a\u9664\u3057\u307e\u3059\u3002",
      confirmText: "\u30ea\u30bb\u30c3\u30c8",
      cancelText: "\u30ad\u30e3\u30f3\u30bb\u30eb",
      danger: true,
    });
    if (!confirmed) return false;
    const identity = currentServerIdentity();
    persistenceGeneration += 1;
    persistenceRevision = 0;
    state = blankState();
    if (identity) state.serverIdentity = { ...identity };
    state.resetPending = true;
    progressMutationRevision = 0;
    progressSyncedRevision = 0;
    runtimeByWorld = new WeakMap();
    dangerFightDeathsByWorld = new WeakMap();
    wireShockTrackers = new WeakMap();
    toastQueue = [];
    toastActive = false;
    emptyClickTimes = [];
    groundChangeTimes = [];
    continuousPlayAccumulatedMs = 0;
    continuousPlayLastHeartbeatAt = Date.now();
    continuousPlayActive = !document.hidden;
    if (global.world) {
      resetWorldProgress(global.world);
      global.world.achievementLastInterventionAt = Math.max(0, Number(global.world.time || 0) || 0);
    }
    saveState();
    recordDailyPlay({ source: "reset" });
    render();
    clearTimeout(showUnlockToast.absorbTimer);
    clearTimeout(showUnlockToast.hideTimer);
    dom.toast?.classList.add("hidden");
    resetUnlockToastVisual();
    dom.button?.classList.remove("achievement-absorb-target");
    global.showToast?.("\u5b9f\u7e3e\u3092\u30ea\u30bb\u30c3\u30c8\u3057\u307e\u3057\u305f\u3002");
    void syncPending();
    return true;
  }

  function unlockAllAchievementsForDebug() {
    if (!DEBUG_MODE) return false;
    const now = Date.now();
    let changed = 0;
    for (const definition of DEFINITIONS) {
      if (state.unlocked[definition.id]) continue;
      state.unlocked[definition.id] = now;
      if (!Array.isArray(state.debugUnlocked)) state.debugUnlocked = [];
      if (!state.debugUnlocked.includes(definition.id)) state.debugUnlocked.push(definition.id);
      changed += 1;
    }
    saveState();
    render();
    global.showToast?.(changed ? `\u5168${DEFINITIONS.length}\u5b9f\u7e3e\u3092\u7372\u5f97\u3057\u307e\u3057\u305f\u3002` : "\u3059\u3079\u3066\u306e\u5b9f\u7e3e\u306f\u7372\u5f97\u6e08\u307f\u3067\u3059\u3002");
    return changed > 0;
  }

  function openDialog() {
    if (global.TarinaiManagedDialogs?.open) global.TarinaiManagedDialogs.open(dom.dialog, dom.button);
    else {
      dom.dialog?.classList.remove("hidden");
      dom.dialog?.setAttribute("aria-hidden", "false");
    }
    render({ forceList: true });
    if (!global.TarinaiManagedDialogs?.open) dom.closeIconButton?.focus?.();
    void syncPending({ full: true });
  }

  function closeDialog() {
    if (global.TarinaiManagedDialogs?.close) global.TarinaiManagedDialogs.close(dom.dialog);
    else {
      dom.dialog?.classList.add("hidden");
      dom.dialog?.setAttribute("aria-hidden", "true");
      dom.button?.focus?.();
    }
  }

  document.addEventListener("visibilitychange", () => {
    const now = Date.now();
    if (document.hidden) {
      if (continuousPlayActive && now >= continuousPlayLastHeartbeatAt) {
        continuousPlayAccumulatedMs += now - continuousPlayLastHeartbeatAt;
      }
      continuousPlayActive = false;
    } else {
      continuousPlayLastHeartbeatAt = now;
      continuousPlayActive = true;
    }
  });
  if (typeof global.setInterval === "function") {
    global.setInterval(() => {
      if (!document.hidden) recordContinuousPlay();
      recordDailyPlay();
      recordLowFps();
      recordHeldTarinai(global.world, Date.now());
    }, 1000);
    if (!DEBUG_MODE) global.setInterval(() => void syncPending({ full: true }), FULL_SYNC_INTERVAL_MS);
  }

  dom.button?.addEventListener("click", () => {
    global.TarinaiAudio?.uiClick?.();
    openDialog();
  });
  dom.closeButton?.addEventListener("click", closeDialog);
  dom.closeIconButton?.addEventListener("click", closeDialog);
  dom.refreshButton?.addEventListener("click", () => void syncPending({ full: true }));
  if (dom.unlockAllButton && DEBUG_MODE) dom.unlockAllButton.hidden = false;
  dom.resetButton?.addEventListener("click", () => void resetAchievements());
  dom.unlockAllButton?.addEventListener("click", unlockAllAchievementsForDebug);
  dom.dialog?.addEventListener("click", event => {
    if (event.target === dom.dialog) closeDialog();
  });
  dom.dialog?.addEventListener("tarinai:dialog-close-request", closeDialog);
  global.addEventListener?.("pagehide", () => {
    saveState();
  });
  document.addEventListener("visibilitychange", () => {
    if (document.hidden) saveState();
  });

  const api = Object.freeze({
    isUnlocked(id) { return Boolean(state.unlocked[String(id || "")]); },
    recordBirth,
    recordDeath,
    recordNaturalZunchiSlave(detail = {}) { recordNaturalStatus("slave", detail); },
    recordNaturalTarinaiKing(detail = {}) { recordNaturalStatus("king", detail); },
    recordDirectFeed,
    recordDirectCare,
    recordConsumableUse,
    recordFirstAidRecovery,
    recordPlushiePokeFling,
    recordIgnition,
    recordIntervention,
    recordPlayerPlacement,
    recordPlayerDeletion,
    recordHistoryAction,
    recordRobotClean,
    importWorldAchievementProgress,
    evaluateCleanFreak,
    recordFightStarted,
    recordShotFired,
    recordLoveMochiBirth,
    recordFavoriteTarinai,
    recordStatsButtonPress,
    recordPushNotificationsEnabled,
    recordManualTarinaiAdded,
    resetWorldProgress,
    recordLinkPlaced,
    recordSignalActivation,
    recordAntPopulation,
    recordAntKilled,
    recordStickyBombPass,
    recordCircuitBoardSignalTransfer,
    recordWirePowerState,
    recordWireShock,
    recordSaveSlotsFilled,
    recordEmptyClick,
    recordGroundChange,
    recordDamageSource,
    recordAntDamageSource,
    exportSpellState,
    importSpellState,
    evaluateWorld,
    evaluateEvent,
    recordSelfZunchiDeath(detail = {}) { return unlock("self_zunchi_death", detail); },
    recordZunchiCollisionDeath(detail = {}) { return unlock("zunchi_collision_death", detail); },
    recordSoccerBallDeath(detail = {}) { return unlock("soccer_ball_death", detail); },
  });
  global.TarinaiAchievements = api;
  if (global.__TARINAI_TEST__) {
    global.TarinaiAchievementTestHooks = Object.freeze({
      state() { return normalizeState(state); },
      growOnlyStateDelta,
      mergeStateData,
      blankState,
      normalizeState,
      progressCounter,
      localProgressSnapshot,
      recordFightPairDangerDeath,
      recordNaturalGeneration,
      definitions: DEFINITIONS,
      categories: ACHIEVEMENT_CATEGORIES,
      definition(id) { return definitionById.get(String(id || "")) || null; },
      refresh() { return syncPending({ full: true }); },
      reset: resetAchievements,
      open: openDialog,
      render(options = {}) { return render(options); },
    });
  }
  setupPersistenceCrossTabSync();
  if (dom.buttonCount) dom.buttonCount.textContent = "…";
  if (dom.dialogCount) dom.dialogCount.textContent = `… / ${DEFINITIONS.length}`;
  persistenceReadyPromise = hydrateDurableState().catch(() => {
    persistenceHydrated = true;
    persistStateNow();
    return true;
  }).then(() => {
    recordDailyPlay({ source: "load" });
    if (!state.unlocked[COMPLETIONIST_ID] && allOtherAchievementsUnlocked()) unlock(COMPLETIONIST_ID, { source: "load" });
    render();
    global.setTimeout(() => recordSaveSlotsFilled(), 0);
    global.setTimeout(() => void syncPending({ full: true }), 700);
    return true;
  });
})(window);