codex-multi-auth 1.1.11 → 1.2.1

package/dist/lib/storage.js

@@ -1,157 +1,81 @@
-import { AsyncLocalStorage } from "node:async_hooks";
-import { createHash } from "node:crypto";
 import { existsSync, promises as fs } from "node:fs";
 import { basename, dirname, join } from "node:path";
 import { ACCOUNT_LIMITS } from "./constants.js";
+import { StorageError } from "./errors.js";
 import { createLogger } from "./logger.js";
-import { exportNamedBackupFile, resolveNamedBackupPath, } from "./named-backup-export.js";
+import { exportNamedBackupFile, getNamedBackupRoot, resolveNamedBackupPath, } from "./named-backup-export.js";
 import { MODEL_FAMILIES } from "./prompts/codex.js";
-import { AnyAccountStorageSchema, getValidationErrors } from "./schemas.js";
+import { clearAccountStorageArtifacts } from "./storage/account-clear.js";
+import { clearAccountsEntry } from "./storage/account-clear-entry.js";
+import { collectDistinctIdentityValues, findNewestMatchingIndex as findNewestMatchingIndexByRef, selectNewestAccount, } from "./storage/account-match-utils.js";
+import { cloneAccountStorageForPersistence } from "./storage/account-persistence.js";
+import { describeAccountSnapshot as describeAccountSnapshotWithDeps, statSnapshot as statSnapshotWithDeps, } from "./storage/account-snapshot.js";
+import { exportAccountsSnapshot, importAccountsSnapshot, } from "./storage/account-port.js";
+import { saveAccountsToDisk } from "./storage/account-save.js";
+import { saveAccountsEntry } from "./storage/account-save-entry.js";
+import { buildBackupMetadata } from "./storage/backup-metadata-builder.js";
+import { buildMetadataSection, } from "./storage/backup-metadata.js";
+import { isCacheLikeBackupArtifactName } from "./storage/cache-artifacts.js";
+import { ACCOUNTS_BACKUP_SUFFIX, ACCOUNTS_WAL_SUFFIX, getAccountsBackupPath, getAccountsBackupRecoveryCandidates, getAccountsWalPath, getIntentionalResetMarkerPath, RESET_MARKER_SUFFIX, } from "./storage/backup-paths.js";
+import { restoreAccountsFromBackupPath } from "./storage/backup-restore.js";
+import { looksLikeSyntheticFixtureStorage } from "./storage/fixture-guards.js";
+import { loadFlaggedAccountsFromFile } from "./storage/flagged-storage-file.js";
+import { clearFlaggedAccountsEntry } from "./storage/flagged-entry.js";
+import { loadFlaggedAccountsEntry } from "./storage/flagged-load-entry.js";
+import { saveFlaggedAccountsEntry } from "./storage/flagged-save-entry.js";
+import { normalizeFlaggedStorage } from "./storage/flagged-storage.js";
+import { clearFlaggedAccountsOnDisk, loadFlaggedAccountsState, saveFlaggedAccountsUnlockedToDisk, } from "./storage/flagged-storage-io.js";
+import { computeSha256 } from "./storage/hash.js";
+import { ensureCodexGitignoreEntry } from "./storage/gitignore.js";
+import { exportAccountsToFile, mergeImportedAccounts, readImportFile, } from "./storage/import-export.js";
+import { formatStorageErrorHint } from "./storage/error-hints.js";
+export { StorageError } from "./errors.js";
+export { formatStorageErrorHint, toStorageError } from "./storage/error-hints.js";
+export { getAccountIdentityKey, normalizeEmailKey, } from "./storage/identity.js";
+import { toAccountIdentityRef, } from "./storage/identity.js";
+import { getFlaggedAccountsPath as buildFlaggedAccountsPath, getLegacyFlaggedAccountsPath as buildLegacyFlaggedAccountsPath, } from "./storage/file-paths.js";
 import { migrateV1ToV3, } from "./storage/migrations.js";
+import { exportNamedBackupEntry } from "./storage/named-backup-entry.js";
+import { collectNamedBackups, } from "./storage/named-backups.js";
+import { getNamedBackupsEntry } from "./storage/named-backups-entry.js";
+import { getStoragePathState, setStoragePathState, } from "./storage/path-state.js";
 import { findProjectRoot, getConfigDir, getProjectConfigDir, getProjectGlobalConfigDir, resolvePath, resolveProjectStorageIdentityRoot, } from "./storage/paths.js";
+import { loadNormalizedStorageFromPath, mergeStorageForMigration, } from "./storage/project-migration.js";
+import { clampIndex, isRecord } from "./storage/record-utils.js";
+import { buildRestoreAssessment } from "./storage/restore-assessment.js";
+import { restoreAccountsFromBackupEntry } from "./storage/restore-backup-entry.js";
+import { createEmptyStorageWithRestoreMetadata as createEmptyStorageWithMetadata, withRestoreMetadata, } from "./storage/restore-metadata.js";
+import { loadAccountsFromPath, parseAndNormalizeStorage, } from "./storage/storage-parser.js";
+import { getTransactionSnapshotState, runInTransactionSnapshotContext, withAccountStorageTransaction as runWithAccountStorageTransaction, withStorageLock, } from "./storage/transactions.js";
 const log = createLogger("storage");
 const ACCOUNTS_FILE_NAME = "openai-codex-accounts.json";
 const FLAGGED_ACCOUNTS_FILE_NAME = "openai-codex-flagged-accounts.json";
 const LEGACY_FLAGGED_ACCOUNTS_FILE_NAME = "openai-codex-blocked-accounts.json";
-const ACCOUNTS_BACKUP_SUFFIX = ".bak";
-const ACCOUNTS_WAL_SUFFIX = ".wal";
 const ACCOUNTS_BACKUP_HISTORY_DEPTH = 3;
 const BACKUP_COPY_MAX_ATTEMPTS = 5;
 const BACKUP_COPY_BASE_DELAY_MS = 10;
-const RESET_MARKER_SUFFIX = ".reset-intent";
 let storageBackupEnabled = true;
 let lastAccountsSaveTimestamp = 0;
-/**
- * Custom error class for storage operations with platform-aware hints.
- */
-export class StorageError extends Error {
-    code;
-    path;
-    hint;
-    constructor(message, code, path, hint, cause) {
-        super(message, { cause });
-        this.name = "StorageError";
-        this.code = code;
-        this.path = path;
-        this.hint = hint;
-    }
-}
-/**
- * Generate platform-aware troubleshooting hint based on error code.
- */
-export function formatStorageErrorHint(error, path) {
-    const err = error;
-    const code = err?.code || "UNKNOWN";
-    const isWindows = process.platform === "win32";
-    switch (code) {
-        case "EACCES":
-        case "EPERM":
-            return isWindows
-                ? `Permission denied writing to ${path}. Check antivirus exclusions for this folder. Ensure you have write permissions.`
-                : `Permission denied writing to ${path}. Check folder permissions. Try: chmod 755 ~/.codex`;
-        case "EBUSY":
-            return `File is locked at ${path}. The file may be open in another program. Close any editors or processes accessing it.`;
-        case "ENOSPC":
-            return `Disk is full. Free up space and try again. Path: ${path}`;
-        case "EEMPTY":
-            return `File written but is empty. This may indicate a disk or filesystem issue. Path: ${path}`;
-        default:
-            return isWindows
-                ? `Failed to write to ${path}. Check folder permissions and ensure path contains no special characters.`
-                : `Failed to write to ${path}. Check folder permissions and disk space.`;
-    }
-}
-let storageMutex = Promise.resolve();
-const transactionSnapshotContext = new AsyncLocalStorage();
-function withStorageLock(fn) {
-    const previousMutex = storageMutex;
-    let releaseLock;
-    storageMutex = new Promise((resolve) => {
-        releaseLock = resolve;
-    });
-    return previousMutex.then(fn).finally(() => releaseLock());
-}
-function looksLikeSyntheticFixtureAccount(account) {
-    const email = typeof account.email === "string" ? account.email.trim().toLowerCase() : "";
-    const refreshToken = typeof account.refreshToken === "string"
-        ? account.refreshToken.trim().toLowerCase()
-        : "";
-    const accountId = typeof account.accountId === "string"
-        ? account.accountId.trim().toLowerCase()
-        : "";
-    if (!/^account\d+@example\.com$/.test(email)) {
-        return false;
-    }
-    const hasSyntheticRefreshToken = refreshToken.startsWith("fake_refresh") ||
-        /^fake_refresh_token_\d+(_for_testing_only)?$/.test(refreshToken);
-    if (!hasSyntheticRefreshToken) {
-        return false;
-    }
-    if (accountId.length === 0) {
-        return true;
-    }
-    return /^acc(_|-)?\d+$/.test(accountId);
-}
-function looksLikeSyntheticFixtureStorage(storage) {
-    if (!storage || storage.accounts.length === 0)
-        return false;
-    return storage.accounts.every((account) => looksLikeSyntheticFixtureAccount(account));
-}
 async function ensureGitignore(storagePath) {
-    if (!currentStoragePath)
+    const state = getStoragePathState();
+    if (!state.currentStoragePath)
         return;
-    const configDir = dirname(storagePath);
-    const inferredProjectRoot = dirname(configDir);
-    const candidateRoots = [currentProjectRoot, inferredProjectRoot].filter((root) => typeof root === "string" && root.length > 0);
-    const projectRoot = candidateRoots.find((root) => existsSync(join(root, ".git")));
-    if (!projectRoot)
-        return;
-    const gitignorePath = join(projectRoot, ".gitignore");
-    try {
-        let content = "";
-        if (existsSync(gitignorePath)) {
-            content = await fs.readFile(gitignorePath, "utf-8");
-            const lines = content.split("\n").map((l) => l.trim());
-            if (lines.includes(".codex") ||
-                lines.includes(".codex/") ||
-                lines.includes("/.codex") ||
-                lines.includes("/.codex/")) {
-                return;
-            }
-        }
-        const newContent = content.endsWith("\n") || content === "" ? content : content + "\n";
-        await fs.writeFile(gitignorePath, newContent + ".codex/\n", "utf-8");
-        log.debug("Added .codex to .gitignore", { path: gitignorePath });
-    }
-    catch (error) {
-        log.warn("Failed to update .gitignore", { error: String(error) });
-    }
+    await ensureCodexGitignoreEntry({
+        storagePath,
+        currentProjectRoot: state.currentProjectRoot,
+        logDebug: (message, details) => {
+            log.debug(message, details);
+        },
+        logWarn: (message, details) => {
+            log.warn(message, details);
+        },
+    });
 }
-let currentStoragePath = null;
-let currentLegacyProjectStoragePath = null;
-let currentLegacyWorktreeStoragePath = null;
-let currentProjectRoot = null;
 export function setStorageBackupEnabled(enabled) {
     storageBackupEnabled = enabled;
 }
-function getAccountsBackupPath(path) {
-    return `${path}${ACCOUNTS_BACKUP_SUFFIX}`;
-}
-function getAccountsBackupPathAtIndex(path, index) {
-    if (index <= 0) {
-        return getAccountsBackupPath(path);
-    }
-    return `${path}${ACCOUNTS_BACKUP_SUFFIX}.${index}`;
-}
-function getAccountsBackupRecoveryCandidates(path) {
-    const candidates = [];
-    for (let i = 0; i < ACCOUNTS_BACKUP_HISTORY_DEPTH; i += 1) {
-        candidates.push(getAccountsBackupPathAtIndex(path, i));
-    }
-    return candidates;
-}
 async function getAccountsBackupRecoveryCandidatesWithDiscovery(path) {
-    const knownCandidates = getAccountsBackupRecoveryCandidates(path);
+    const knownCandidates = getAccountsBackupRecoveryCandidates(path, ACCOUNTS_BACKUP_HISTORY_DEPTH);
     const discoveredCandidates = new Set();
     const candidatePrefix = `${basename(path)}.`;
     const knownCandidateSet = new Set(knownCandidates);
@@ -191,9 +115,6 @@ async function getAccountsBackupRecoveryCandidatesWithDiscovery(path) {
     const discoveredOrdered = Array.from(discoveredCandidates).sort((a, b) => a.localeCompare(b, undefined, { sensitivity: "base" }));
     return [...knownCandidates, ...discoveredOrdered];
 }
-function getAccountsWalPath(path) {
-    return `${path}${ACCOUNTS_WAL_SUFFIX}`;
-}
 async function copyFileWithRetry(sourcePath, destinationPath, options) {
     const allowMissingSource = options?.allowMissingSource ?? false;
     for (let attempt = 0; attempt < BACKUP_COPY_MAX_ATTEMPTS; attempt += 1) {
@@ -235,7 +156,7 @@ async function renameFileWithRetry(sourcePath, destinationPath) {
     }
 }
 async function createRotatingAccountsBackup(path) {
-    const candidates = getAccountsBackupRecoveryCandidates(path);
+    const candidates = getAccountsBackupRecoveryCandidates(path, ACCOUNTS_BACKUP_HISTORY_DEPTH);
     const rotationNonce = `${Date.now()}.${Math.random().toString(36).slice(2, 8)}`;
     const stagedWrites = [];
     const buildStagedPath = (targetPath, label) => `${targetPath}.rotate.${rotationNonce}.${label}.tmp`;
@@ -336,86 +257,22 @@ async function cleanupStaleRotatingBackupArtifacts(path) {
         }
     }
 }
-function computeSha256(value) {
-    return createHash("sha256").update(value).digest("hex");
-}
-function getIntentionalResetMarkerPath(path) {
-    return `${path}${RESET_MARKER_SUFFIX}`;
-}
-function createEmptyStorageWithMetadata(restoreEligible, restoreReason) {
-    return {
-        version: 3,
-        accounts: [],
-        activeIndex: 0,
-        activeIndexByFamily: {},
-        restoreEligible,
-        restoreReason,
-    };
-}
-function withRestoreMetadata(storage, restoreEligible, restoreReason) {
-    return {
-        ...storage,
-        restoreEligible,
-        restoreReason,
-    };
-}
-function isCacheLikeBackupArtifactName(entryName) {
-    return entryName.toLowerCase().includes(".cache");
-}
 async function statSnapshot(path) {
-    try {
-        const stats = await fs.stat(path);
-        return { exists: true, bytes: stats.size, mtimeMs: stats.mtimeMs };
-    }
-    catch (error) {
-        const code = error.code;
-        if (code !== "ENOENT") {
-            log.warn("Failed to stat backup candidate", {
-                path,
-                error: String(error),
-            });
-        }
-        return { exists: false };
-    }
+    return statSnapshotWithDeps(path, {
+        stat: fs.stat,
+        logWarn: (message, meta) => log.warn(message, meta),
+    });
 }
 async function describeAccountSnapshot(path, kind, index) {
-    const stats = await statSnapshot(path);
-    if (!stats.exists) {
-        return { kind, path, index, exists: false, valid: false };
-    }
-    try {
-        const { normalized, schemaErrors, storedVersion } = await loadAccountsFromPath(path);
-        return {
-            kind,
-            path,
-            index,
-            exists: true,
-            valid: !!normalized,
-            bytes: stats.bytes,
-            mtimeMs: stats.mtimeMs,
-            version: typeof storedVersion === "number" ? storedVersion : undefined,
-            accountCount: normalized?.accounts.length,
-            schemaErrors: schemaErrors.length > 0 ? schemaErrors : undefined,
-        };
-    }
-    catch (error) {
-        const code = error.code;
-        if (code !== "ENOENT") {
-            log.warn("Failed to inspect account snapshot", {
-                path,
-                error: String(error),
-            });
-        }
-        return {
-            kind,
-            path,
-            index,
-            exists: true,
-            valid: false,
-            bytes: stats.bytes,
-            mtimeMs: stats.mtimeMs,
-        };
-    }
+    return describeAccountSnapshotWithDeps(path, kind, {
+        index,
+        statSnapshot,
+        loadAccountsFromPath: (targetPath) => loadAccountsFromPath(targetPath, {
+            normalizeAccountStorage,
+            isRecord,
+        }),
+        logWarn: (message, meta) => log.warn(message, meta),
+    });
 }
 async function describeAccountsWalSnapshot(path) {
     const stats = await statSnapshot(path);
@@ -449,7 +306,7 @@ async function describeAccountsWalSnapshot(path) {
                 mtimeMs: stats.mtimeMs,
             };
         }
-        const { normalized, storedVersion, schemaErrors } = parseAndNormalizeStorage(JSON.parse(entry.content));
+        const { normalized, storedVersion, schemaErrors } = parseAndNormalizeStorage(JSON.parse(entry.content), normalizeAccountStorage, isRecord);
         return {
             kind: "accounts-wal",
             path,
@@ -474,9 +331,13 @@ async function describeAccountsWalSnapshot(path) {
     }
 }
 async function loadFlaggedAccountsFromPath(path) {
-    const content = await fs.readFile(path, "utf-8");
-    const data = JSON.parse(content);
-    return normalizeFlaggedStorage(data);
+    return loadFlaggedAccountsFromFile(path, {
+        readFile: fs.readFile,
+        normalizeFlaggedStorage: (data) => normalizeFlaggedStorage(data, {
+            isRecord,
+            now: () => Date.now(),
+        }),
+    });
 }
 async function describeFlaggedSnapshot(path, kind, index) {
     const stats = await statSnapshot(path);
@@ -516,93 +377,124 @@ async function describeFlaggedSnapshot(path, kind, index) {
         };
     }
 }
-function latestValidSnapshot(snapshots) {
-    return snapshots
-        .filter((snapshot) => snapshot.valid)
-        .sort((left, right) => (right.mtimeMs ?? 0) - (left.mtimeMs ?? 0))[0];
-}
-function buildMetadataSection(storagePath, snapshots) {
-    const latestValid = latestValidSnapshot(snapshots);
-    return {
-        storagePath,
-        latestValidPath: latestValid?.path,
-        snapshotCount: snapshots.length,
-        validSnapshotCount: snapshots.filter((snapshot) => snapshot.valid).length,
-        snapshots,
-    };
-}
 export function getLastAccountsSaveTimestamp() {
     return lastAccountsSaveTimestamp;
 }
 export function setStoragePath(projectPath) {
     if (!projectPath) {
-        currentStoragePath = null;
-        currentLegacyProjectStoragePath = null;
-        currentLegacyWorktreeStoragePath = null;
-        currentProjectRoot = null;
+        setStoragePathState({
+            currentStoragePath: null,
+            currentLegacyProjectStoragePath: null,
+            currentLegacyWorktreeStoragePath: null,
+            currentProjectRoot: null,
+        });
         return;
     }
     const projectRoot = findProjectRoot(projectPath);
     if (projectRoot) {
-        currentProjectRoot = projectRoot;
         const identityRoot = resolveProjectStorageIdentityRoot(projectRoot);
-        currentStoragePath = join(getProjectGlobalConfigDir(identityRoot), ACCOUNTS_FILE_NAME);
-        currentLegacyProjectStoragePath = join(getProjectConfigDir(projectRoot), ACCOUNTS_FILE_NAME);
+        const currentStoragePath = join(getProjectGlobalConfigDir(identityRoot), ACCOUNTS_FILE_NAME);
+        const currentLegacyProjectStoragePath = join(getProjectConfigDir(projectRoot), ACCOUNTS_FILE_NAME);
         const previousWorktreeScopedPath = join(getProjectGlobalConfigDir(projectRoot), ACCOUNTS_FILE_NAME);
-        currentLegacyWorktreeStoragePath =
-            previousWorktreeScopedPath !== currentStoragePath
-                ? previousWorktreeScopedPath
-                : null;
+        const currentLegacyWorktreeStoragePath = previousWorktreeScopedPath !== currentStoragePath
+            ? previousWorktreeScopedPath
+            : null;
+        setStoragePathState({
+            currentStoragePath,
+            currentLegacyProjectStoragePath,
+            currentLegacyWorktreeStoragePath,
+            currentProjectRoot: projectRoot,
+        });
     }
     else {
-        currentStoragePath = null;
-        currentLegacyProjectStoragePath = null;
-        currentLegacyWorktreeStoragePath = null;
-        currentProjectRoot = null;
+        setStoragePathState({
+            currentStoragePath: null,
+            currentLegacyProjectStoragePath: null,
+            currentLegacyWorktreeStoragePath: null,
+            currentProjectRoot: null,
+        });
     }
 }
 export function setStoragePathDirect(path) {
-    currentStoragePath = path;
-    currentLegacyProjectStoragePath = null;
-    currentLegacyWorktreeStoragePath = null;
-    currentProjectRoot = null;
+    setStoragePathState({
+        currentStoragePath: path,
+        currentLegacyProjectStoragePath: null,
+        currentLegacyWorktreeStoragePath: null,
+        currentProjectRoot: null,
+    });
 }
 /**
  * Returns the file path for the account storage JSON file.
  * @returns Absolute path to the accounts.json file
  */
 export function getStoragePath() {
-    if (currentStoragePath) {
-        return currentStoragePath;
+    const state = getStoragePathState();
+    if (state.currentStoragePath) {
+        return state.currentStoragePath;
     }
     return join(getConfigDir(), ACCOUNTS_FILE_NAME);
 }
 export function buildNamedBackupPath(name) {
     return resolveNamedBackupPath(name, getStoragePath());
 }
+export async function getNamedBackups() {
+    return getNamedBackupsEntry({
+        getStoragePath,
+        collectNamedBackups,
+        loadAccountsFromPath: (path) => loadAccountsFromPath(path, {
+            normalizeAccountStorage,
+            isRecord,
+        }),
+        logDebug: (message, details) => {
+            log.debug(message, details);
+        },
+    });
+}
+export async function restoreAccountsFromBackup(path, options) {
+    return restoreAccountsFromBackupEntry({
+        path,
+        options,
+        restoreAccountsFromBackupPath,
+        getNamedBackupRoot,
+        getStoragePath,
+        realpath: fs.realpath,
+        loadAccountsFromPath: (path) => loadAccountsFromPath(path, {
+            normalizeAccountStorage,
+            isRecord,
+        }),
+        saveAccounts,
+    });
+}
 export async function exportNamedBackup(name, options) {
-    return exportNamedBackupFile(name, {
+    return exportNamedBackupEntry({
+        name,
+        options,
+        exportNamedBackupFile,
         getStoragePath,
         exportAccounts,
-    }, options);
+    });
 }
 export function getFlaggedAccountsPath() {
-    return join(dirname(getStoragePath()), FLAGGED_ACCOUNTS_FILE_NAME);
+    return buildFlaggedAccountsPath(getStoragePath(), FLAGGED_ACCOUNTS_FILE_NAME);
 }
 function getLegacyFlaggedAccountsPath() {
-    return join(dirname(getStoragePath()), LEGACY_FLAGGED_ACCOUNTS_FILE_NAME);
+    return buildLegacyFlaggedAccountsPath(getStoragePath(), LEGACY_FLAGGED_ACCOUNTS_FILE_NAME);
 }
-async function migrateLegacyProjectStorageIfNeeded(persist = saveAccounts) {
-    if (!currentStoragePath) {
+async function migrateLegacyProjectStorageIfNeeded(options) {
+    const persist = options?.persist ?? saveAccounts;
+    const commit = options?.commit ?? true;
+    const state = getStoragePathState();
+    if (!state.currentStoragePath) {
         return null;
     }
+    const currentStoragePath = state.currentStoragePath;
     const candidatePaths = [
-        currentLegacyWorktreeStoragePath,
-        currentLegacyProjectStoragePath,
+        state.currentLegacyWorktreeStoragePath,
+        state.currentLegacyProjectStoragePath,
     ]
         .filter((path) => typeof path === "string" &&
         path.length > 0 &&
-        path !== currentStoragePath)
+        path !== state.currentStoragePath)
         .filter((path, index, all) => all.indexOf(path) === index);
     if (candidatePaths.length === 0) {
         return null;
@@ -611,49 +503,106 @@ async function migrateLegacyProjectStorageIfNeeded(persist = saveAccounts) {
     if (existingCandidatePaths.length === 0) {
         return null;
     }
-    let targetStorage = await loadNormalizedStorageFromPath(currentStoragePath, "current account storage");
-    let migrated = false;
-    for (const legacyPath of existingCandidatePaths) {
-        const legacyStorage = await loadNormalizedStorageFromPath(legacyPath, "legacy account storage");
-        if (!legacyStorage) {
-            continue;
+    const loadCurrentStorageForMigration = async () => loadNormalizedStorageFromPath(currentStoragePath, "current account storage", {
+        loadAccountsFromPath: (path) => loadAccountsFromPath(path, {
+            normalizeAccountStorage,
+            isRecord,
+        }),
+        logWarn: (message, details) => {
+            log.warn(message, details);
+        },
+    });
+    const readLiveCurrentStorageIfExportMode = async () => {
+        if (commit || !existsSync(currentStoragePath)) {
+            return { exists: false, storage: null };
         }
-        const mergedStorage = mergeStorageForMigration(targetStorage, legacyStorage);
-        const fallbackStorage = targetStorage ?? legacyStorage;
         try {
-            await persist(mergedStorage);
-            targetStorage = mergedStorage;
-            migrated = true;
+            const { normalized, schemaErrors } = await loadAccountsFromPath(currentStoragePath, {
+                normalizeAccountStorage,
+                isRecord,
+            });
+            if (schemaErrors.length > 0) {
+                log.warn("current account storage schema validation warnings", {
+                    path: currentStoragePath,
+                    errors: schemaErrors.slice(0, 5),
+                });
+            }
+            return {
+                exists: true,
+                storage: normalized,
+            };
         }
         catch (error) {
-            targetStorage = fallbackStorage;
-            log.warn("Failed to persist migrated account storage", {
-                from: legacyPath,
-                to: currentStoragePath,
-                error: String(error),
-            });
+            if (error.code === "ENOENT") {
+                return { exists: false, storage: null };
+            }
+            throw error;
+        }
+    };
+    let targetStorage = await loadCurrentStorageForMigration();
+    let migrated = false;
+    for (const legacyPath of existingCandidatePaths) {
+        const liveCurrentStorageBeforeMerge = await readLiveCurrentStorageIfExportMode();
+        if (liveCurrentStorageBeforeMerge.exists) {
+            return liveCurrentStorageBeforeMerge.storage;
+        }
+        const legacyStorage = await loadNormalizedStorageFromPath(legacyPath, "legacy account storage", {
+            loadAccountsFromPath: (path) => loadAccountsFromPath(path, {
+                normalizeAccountStorage,
+                isRecord,
+            }),
+            logWarn: (message, details) => {
+                log.warn(message, details);
+            },
+        });
+        if (!legacyStorage) {
             continue;
         }
-        try {
-            await fs.unlink(legacyPath);
-            log.info("Removed legacy account storage file after migration", {
-                path: legacyPath,
-            });
+        const liveCurrentStorageAfterLegacyRead = await readLiveCurrentStorageIfExportMode();
+        if (liveCurrentStorageAfterLegacyRead.exists) {
+            return liveCurrentStorageAfterLegacyRead.storage;
         }
-        catch (unlinkError) {
-            const code = unlinkError.code;
-            if (code !== "ENOENT") {
-                log.warn("Failed to remove legacy account storage file after migration", {
+        const mergedStorage = mergeStorageForMigration(targetStorage, legacyStorage, normalizeAccountStorage);
+        const fallbackStorage = targetStorage ?? legacyStorage;
+        if (commit) {
+            try {
+                await persist(mergedStorage);
+                targetStorage = mergedStorage;
+                migrated = true;
+            }
+            catch (error) {
+                targetStorage = fallbackStorage;
+                log.warn("Failed to persist migrated account storage", {
+                    from: legacyPath,
+                    to: currentStoragePath,
+                    error: String(error),
+                });
+                continue;
+            }
+            try {
+                await fs.unlink(legacyPath);
+                log.info("Removed legacy account storage file after migration", {
                     path: legacyPath,
-                    error: String(unlinkError),
                 });
             }
+            catch (unlinkError) {
+                const code = unlinkError.code;
+                if (code !== "ENOENT") {
+                    log.warn("Failed to remove legacy account storage file after migration", {
+                        path: legacyPath,
+                        error: String(unlinkError),
+                    });
+                }
+            }
+            log.info("Migrated legacy project account storage", {
+                from: legacyPath,
+                to: currentStoragePath,
+                accounts: mergedStorage.accounts.length,
+            });
+            continue;
         }
-        log.info("Migrated legacy project account storage", {
-            from: legacyPath,
-            to: currentStoragePath,
-            accounts: mergedStorage.accounts.length,
-        });
+        targetStorage = mergedStorage;
+        migrated = true;
     }
     if (migrated) {
         return targetStorage;
@@ -663,129 +612,8 @@ async function migrateLegacyProjectStorageIfNeeded(persist = saveAccounts) {
     }
     return null;
 }
-async function loadNormalizedStorageFromPath(path, label) {
-    try {
-        const { normalized, schemaErrors } = await loadAccountsFromPath(path);
-        if (schemaErrors.length > 0) {
-            log.warn(`${label} schema validation warnings`, {
-                path,
-                errors: schemaErrors.slice(0, 5),
-            });
-        }
-        return normalized;
-    }
-    catch (error) {
-        const code = error.code;
-        if (code !== "ENOENT") {
-            log.warn(`Failed to load ${label}`, {
-                path,
-                error: String(error),
-            });
-        }
-        return null;
-    }
-}
-function mergeStorageForMigration(current, incoming) {
-    if (!current) {
-        return incoming;
-    }
-    const merged = normalizeAccountStorage({
-        version: 3,
-        activeIndex: current.activeIndex,
-        activeIndexByFamily: current.activeIndexByFamily,
-        accounts: [...current.accounts, ...incoming.accounts],
-    });
-    if (!merged) {
-        return current;
-    }
-    return merged;
-}
-function selectNewestAccount(current, candidate) {
-    if (!current)
-        return candidate;
-    const currentLastUsed = current.lastUsed || 0;
-    const candidateLastUsed = candidate.lastUsed || 0;
-    if (candidateLastUsed > currentLastUsed)
-        return candidate;
-    if (candidateLastUsed < currentLastUsed)
-        return current;
-    const currentAddedAt = current.addedAt || 0;
-    const candidateAddedAt = candidate.addedAt || 0;
-    return candidateAddedAt >= currentAddedAt ? candidate : current;
-}
-function normalizeAccountIdKey(accountId) {
-    if (!accountId)
-        return undefined;
-    const trimmed = accountId.trim();
-    return trimmed || undefined;
-}
-/**
- * Normalize email keys for case-insensitive account identity matching.
- */
-export function normalizeEmailKey(email) {
-    if (!email)
-        return undefined;
-    const trimmed = email.trim();
-    if (!trimmed)
-        return undefined;
-    return trimmed.toLowerCase();
-}
-function normalizeRefreshTokenKey(refreshToken) {
-    if (!refreshToken)
-        return undefined;
-    const trimmed = refreshToken.trim();
-    return trimmed || undefined;
-}
-function toAccountIdentityRef(account) {
-    return {
-        accountId: normalizeAccountIdKey(account?.accountId),
-        emailKey: normalizeEmailKey(account?.email),
-        refreshToken: normalizeRefreshTokenKey(account?.refreshToken),
-    };
-}
-function collectDistinctIdentityValues(values) {
-    const distinct = new Set();
-    for (const value of values) {
-        if (value)
-            distinct.add(value);
-    }
-    return distinct;
-}
-export function getAccountIdentityKey(account) {
-    const ref = toAccountIdentityRef(account);
-    if (ref.accountId && ref.emailKey) {
-        return `account:${ref.accountId}::email:${ref.emailKey}`;
-    }
-    if (ref.accountId)
-        return `account:${ref.accountId}`;
-    if (ref.emailKey)
-        return `email:${ref.emailKey}`;
-    if (ref.refreshToken)
-        return `refresh:${ref.refreshToken}`;
-    return undefined;
-}
 function findNewestMatchingIndex(accounts, predicate) {
-    let matchIndex;
-    let match;
-    for (let i = 0; i < accounts.length; i += 1) {
-        const account = accounts[i];
-        if (!account)
-            continue;
-        const ref = toAccountIdentityRef(account);
-        if (!predicate(ref))
-            continue;
-        if (matchIndex === undefined) {
-            matchIndex = i;
-            match = account;
-            continue;
-        }
-        const newest = selectNewestAccount(match, account);
-        if (newest === account) {
-            matchIndex = i;
-            match = account;
-        }
-    }
-    return matchIndex;
+    return findNewestMatchingIndexByRef(accounts, (account) => toAccountIdentityRef(account), predicate, selectNewestAccount);
 }
 function findCompositeAccountMatchIndex(accounts, candidateRef) {
     if (!candidateRef.accountId || !candidateRef.emailKey)
@@ -932,14 +760,6 @@ export function deduplicateAccounts(accounts) {
 export function deduplicateAccountsByEmail(accounts) {
     return deduplicateAccountsByIdentity(accounts);
 }
-function isRecord(value) {
-    return !!value && typeof value === "object" && !Array.isArray(value);
-}
-function clampIndex(index, length) {
-    if (length <= 0)
-        return 0;
-    return Math.max(0, Math.min(index, length - 1));
-}
 function extractActiveAccountRef(accounts, activeIndex) {
     const candidate = accounts[activeIndex];
     if (!isRecord(candidate))
@@ -1030,92 +850,27 @@ export async function loadAccounts() {
 }
 export async function getBackupMetadata() {
     const storagePath = getStoragePath();
-    const walPath = getAccountsWalPath(storagePath);
-    const accountCandidates = await getAccountsBackupRecoveryCandidatesWithDiscovery(storagePath);
-    const accountSnapshots = [
-        await describeAccountSnapshot(storagePath, "accounts-primary"),
-        await describeAccountsWalSnapshot(walPath),
-    ];
-    for (const [index, candidate] of accountCandidates.entries()) {
-        const kind = candidate === `${storagePath}.bak`
-            ? "accounts-backup"
-            : candidate.startsWith(`${storagePath}.bak.`)
-                ? "accounts-backup-history"
-                : "accounts-discovered-backup";
-        accountSnapshots.push(await describeAccountSnapshot(candidate, kind, index));
-    }
     const flaggedPath = getFlaggedAccountsPath();
-    const flaggedCandidates = await getAccountsBackupRecoveryCandidatesWithDiscovery(flaggedPath);
-    const flaggedSnapshots = [
-        await describeFlaggedSnapshot(flaggedPath, "flagged-primary"),
-    ];
-    for (const [index, candidate] of flaggedCandidates.entries()) {
-        const kind = candidate === `${flaggedPath}.bak`
-            ? "flagged-backup"
-            : candidate.startsWith(`${flaggedPath}.bak.`)
-                ? "flagged-backup-history"
-                : "flagged-discovered-backup";
-        flaggedSnapshots.push(await describeFlaggedSnapshot(candidate, kind, index));
-    }
-    return {
-        accounts: buildMetadataSection(storagePath, accountSnapshots),
-        flaggedAccounts: buildMetadataSection(flaggedPath, flaggedSnapshots),
-    };
+    return buildBackupMetadata({
+        storagePath,
+        flaggedPath,
+        walPath: getAccountsWalPath(storagePath),
+        getAccountsBackupRecoveryCandidatesWithDiscovery,
+        describeAccountSnapshot,
+        describeAccountsWalSnapshot,
+        describeFlaggedSnapshot,
+        buildMetadataSection,
+    });
 }
 export async function getRestoreAssessment() {
     const storagePath = getStoragePath();
     const resetMarkerPath = getIntentionalResetMarkerPath(storagePath);
     const backupMetadata = await getBackupMetadata();
-    if (existsSync(resetMarkerPath)) {
-        return {
-            storagePath,
-            restoreEligible: false,
-            restoreReason: "intentional-reset",
-            backupMetadata,
-        };
-    }
-    const primarySnapshot = backupMetadata.accounts.snapshots.find((snapshot) => snapshot.kind === "accounts-primary");
-    if (!primarySnapshot?.exists) {
-        return {
-            storagePath,
-            restoreEligible: true,
-            restoreReason: "missing-storage",
-            latestSnapshot: backupMetadata.accounts.latestValidPath
-                ? backupMetadata.accounts.snapshots.find((snapshot) => snapshot.path === backupMetadata.accounts.latestValidPath)
-                : undefined,
-            backupMetadata,
-        };
-    }
-    if (primarySnapshot.valid && primarySnapshot.accountCount === 0) {
-        return {
-            storagePath,
-            restoreEligible: true,
-            restoreReason: "empty-storage",
-            latestSnapshot: primarySnapshot,
-            backupMetadata,
-        };
-    }
-    return {
+    return buildRestoreAssessment({
         storagePath,
-        restoreEligible: false,
-        latestSnapshot: backupMetadata.accounts.latestValidPath
-            ? backupMetadata.accounts.snapshots.find((snapshot) => snapshot.path === backupMetadata.accounts.latestValidPath)
-            : undefined,
         backupMetadata,
-    };
-}
-function parseAndNormalizeStorage(data) {
-    const schemaErrors = getValidationErrors(AnyAccountStorageSchema, data);
-    const normalized = normalizeAccountStorage(data);
-    const storedVersion = isRecord(data)
-        ? data.version
-        : undefined;
-    return { normalized, storedVersion, schemaErrors };
-}
-async function loadAccountsFromPath(path) {
-    const content = await fs.readFile(path, "utf-8");
-    const data = JSON.parse(content);
-    return parseAndNormalizeStorage(data);
+        hasResetMarker: existsSync(resetMarkerPath),
+    });
 }
 async function loadAccountsFromJournal(path) {
     const walPath = getAccountsWalPath(path);
@@ -1142,7 +897,7 @@ async function loadAccountsFromJournal(path) {
             return null;
         }
         const data = JSON.parse(entry.content);
-        const { normalized } = parseAndNormalizeStorage(data);
+        const { normalized } = parseAndNormalizeStorage(data, normalizeAccountStorage, isRecord);
         if (!normalized)
             return null;
         log.warn("Recovered account storage from WAL journal", { path, walPath });
@@ -1164,10 +919,13 @@ async function loadAccountsInternal(persistMigration) {
     const resetMarkerPath = getIntentionalResetMarkerPath(path);
     await cleanupStaleRotatingBackupArtifacts(path);
     const migratedLegacyStorage = persistMigration
-        ? await migrateLegacyProjectStorageIfNeeded(persistMigration)
+        ? await migrateLegacyProjectStorageIfNeeded({ persist: persistMigration })
         : null;
     try {
-        const { normalized, storedVersion, schemaErrors } = await loadAccountsFromPath(path);
+        const { normalized, storedVersion, schemaErrors } = await loadAccountsFromPath(path, {
+            normalizeAccountStorage,
+            isRecord,
+        });
         if (schemaErrors.length > 0) {
             log.warn("Account storage schema validation warnings", {
                 errors: schemaErrors.slice(0, 5),
@@ -1202,7 +960,10 @@ async function loadAccountsInternal(persistMigration) {
                 if (backupPath === path)
                     continue;
                 try {
-                    const backup = await loadAccountsFromPath(backupPath);
+                    const backup = await loadAccountsFromPath(backupPath, {
+                        normalizeAccountStorage,
+                        isRecord,
+                    });
                     if (!backup.normalized)
                         continue;
                     if (looksLikeSyntheticFixtureStorage(backup.normalized))
@@ -1271,7 +1032,10 @@ async function loadAccountsInternal(persistMigration) {
             const backupCandidates = await getAccountsBackupRecoveryCandidatesWithDiscovery(path);
             for (const backupPath of backupCandidates) {
                 try {
-                    const backup = await loadAccountsFromPath(backupPath);
+                    const backup = await loadAccountsFromPath(backupPath, {
+                        normalizeAccountStorage,
+                        isRecord,
+                    });
                     if (backup.schemaErrors.length > 0) {
                         log.warn("Backup account storage schema validation warnings", {
                             path: backupPath,
@@ -1317,151 +1081,179 @@ async function loadAccountsInternal(persistMigration) {
         return null;
     }
 }
+async function loadAccountsForExport() {
+    // Export reuses this helper from both paths in `exportAccounts()`. Keep the
+    // read side effect free so export never clears a reset marker or races with
+    // concurrent writers while normalizing legacy storage for the snapshot.
+    const path = getStoragePath();
+    const resetMarkerPath = getIntentionalResetMarkerPath(path);
+    if (existsSync(resetMarkerPath)) {
+        return createEmptyStorageWithMetadata(false, "intentional-reset");
+    }
+    try {
+        const { normalized, schemaErrors } = await loadAccountsFromPath(path, {
+            normalizeAccountStorage,
+            isRecord,
+        });
+        if (schemaErrors.length > 0) {
+            log.warn("Account storage schema validation warnings", {
+                errors: schemaErrors.slice(0, 5),
+            });
+        }
+        if (existsSync(resetMarkerPath)) {
+            return createEmptyStorageWithMetadata(false, "intentional-reset");
+        }
+        return normalized;
+    }
+    catch (error) {
+        const code = error.code;
+        if (existsSync(resetMarkerPath)) {
+            return createEmptyStorageWithMetadata(false, "intentional-reset");
+        }
+        if (code === "ENOENT") {
+            const migratedLegacyStorage = await migrateLegacyProjectStorageIfNeeded({ commit: false });
+            if (existsSync(resetMarkerPath)) {
+                return createEmptyStorageWithMetadata(false, "intentional-reset");
+            }
+            return migratedLegacyStorage;
+        }
+        throw error;
+    }
+}
 async function saveAccountsUnlocked(storage) {
     const path = getStoragePath();
     const resetMarkerPath = getIntentionalResetMarkerPath(path);
-    const uniqueSuffix = `${Date.now()}.${Math.random().toString(36).slice(2, 8)}`;
-    const tempPath = `${path}.${uniqueSuffix}.tmp`;
     const walPath = getAccountsWalPath(path);
-    try {
-        await fs.mkdir(dirname(path), { recursive: true });
-        await ensureGitignore(path);
-        if (looksLikeSyntheticFixtureStorage(storage)) {
-            try {
-                const existing = await loadNormalizedStorageFromPath(path, "existing account storage");
-                if (existing &&
-                    existing.accounts.length > 0 &&
-                    !looksLikeSyntheticFixtureStorage(existing)) {
-                    throw new StorageError("Refusing to overwrite non-synthetic account storage with synthetic fixture payload", "EINVALID", path, "Detected synthetic fixture-like account payload. Use explicit account import/login commands instead.");
+    return saveAccountsToDisk(storage, {
+        path,
+        resetMarkerPath,
+        walPath,
+        storageBackupEnabled: storageBackupEnabled && existsSync(path),
+        ensureDirectory: async () => {
+            await fs.mkdir(dirname(path), { recursive: true });
+        },
+        ensureGitignore: () => ensureGitignore(path),
+        looksLikeSyntheticFixtureStorage,
+        loadExistingStorage: () => loadNormalizedStorageFromPath(path, "existing account storage", {
+            loadAccountsFromPath: (candidatePath) => loadAccountsFromPath(candidatePath, {
+                normalizeAccountStorage,
+                isRecord,
+            }),
+            logWarn: (message, details) => {
+                log.warn(message, details);
+            },
+        }),
+        createSyntheticFixtureError: () => new StorageError("Refusing to overwrite non-synthetic account storage with synthetic fixture payload", "EINVALID", path, "Detected synthetic fixture-like account payload. Use explicit account import/login commands instead."),
+        createRotatingAccountsBackup,
+        computeSha256,
+        writeJournal: async (content, journalPath) => {
+            const journalEntry = {
+                version: 1,
+                createdAt: Date.now(),
+                path: journalPath,
+                checksum: computeSha256(content),
+                content,
+            };
+            await fs.writeFile(walPath, JSON.stringify(journalEntry), {
+                encoding: "utf-8",
+                mode: 0o600,
+            });
+        },
+        writeTemp: (tempPath, content) => fs.writeFile(tempPath, content, { encoding: "utf-8", mode: 0o600 }),
+        statTemp: (tempPath) => fs.stat(tempPath),
+        renameTempToPath: async (tempPath) => {
+            let lastError = null;
+            for (let attempt = 0; attempt < 5; attempt++) {
+                try {
+                    await fs.rename(tempPath, path);
+                    return;
                 }
-            }
-            catch (error) {
-                if (error instanceof StorageError) {
-                    throw error;
+                catch (renameError) {
+                    const code = renameError.code;
+                    if (code === "EPERM" || code === "EBUSY") {
+                        lastError = renameError;
+                        await new Promise((r) => setTimeout(r, 10 * 2 ** attempt));
+                        continue;
+                    }
+                    throw renameError;
                 }
-                // Ignore existing-file probe failures and continue with normal save flow.
             }
-        }
-        if (storageBackupEnabled && existsSync(path)) {
+            if (lastError)
+                throw lastError;
+        },
+        cleanupResetMarker: async () => {
             try {
-                await createRotatingAccountsBackup(path);
+                await fs.unlink(resetMarkerPath);
             }
-            catch (backupError) {
-                log.warn("Failed to create account storage backup", {
-                    path,
-                    backupPath: getAccountsBackupPath(path),
-                    error: String(backupError),
-                });
+            catch {
+                // Best effort cleanup.
             }
-        }
-        const content = JSON.stringify(storage, null, 2);
-        const journalEntry = {
-            version: 1,
-            createdAt: Date.now(),
-            path,
-            checksum: computeSha256(content),
-            content,
-        };
-        await fs.writeFile(walPath, JSON.stringify(journalEntry), {
-            encoding: "utf-8",
-            mode: 0o600,
-        });
-        await fs.writeFile(tempPath, content, { encoding: "utf-8", mode: 0o600 });
-        const stats = await fs.stat(tempPath);
-        if (stats.size === 0) {
-            const emptyError = Object.assign(new Error("File written but size is 0"), { code: "EEMPTY" });
-            throw emptyError;
-        }
-        // Retry rename with exponential backoff for Windows EPERM/EBUSY
-        let lastError = null;
-        for (let attempt = 0; attempt < 5; attempt++) {
+        },
+        cleanupWal: async () => {
             try {
-                await fs.rename(tempPath, path);
-                try {
-                    await fs.unlink(resetMarkerPath);
-                }
-                catch {
-                    // Best effort cleanup.
-                }
-                lastAccountsSaveTimestamp = Date.now();
-                try {
-                    await fs.unlink(walPath);
-                }
-                catch {
-                    // Best effort cleanup.
-                }
-                return;
+                await fs.unlink(walPath);
             }
-            catch (renameError) {
-                const code = renameError.code;
-                if (code === "EPERM" || code === "EBUSY") {
-                    lastError = renameError;
-                    await new Promise((r) => setTimeout(r, 10 * 2 ** attempt));
-                    continue;
-                }
-                throw renameError;
+            catch {
+                // Best effort cleanup.
             }
-        }
-        if (lastError)
-            throw lastError;
-    }
-    catch (error) {
-        try {
-            await fs.unlink(tempPath);
-        }
-        catch {
-            // Ignore cleanup failure.
-        }
-        const err = error;
-        const code = err?.code || "UNKNOWN";
-        const hint = formatStorageErrorHint(error, path);
-        log.error("Failed to save accounts", {
-            path,
-            code,
-            message: err?.message,
-            hint,
-        });
-        throw new StorageError(`Failed to save accounts: ${err?.message || "Unknown error"}`, code, path, hint, err instanceof Error ? err : undefined);
-    }
+        },
+        cleanupTemp: async (tempPath) => {
+            try {
+                await fs.unlink(tempPath);
+            }
+            catch {
+                // Ignore cleanup failure.
+            }
+        },
+        onSaved: () => {
+            lastAccountsSaveTimestamp = Date.now();
+        },
+        logWarn: (message, details) => {
+            log.warn(message, details);
+        },
+        logError: (message, details) => {
+            log.error(message, details);
+        },
+        createStorageError: (error) => {
+            const err = error;
+            const code = err?.code || "UNKNOWN";
+            const hint = formatStorageErrorHint(error, path);
+            return new StorageError(`Failed to save accounts: ${err?.message || "Unknown error"}`, code, path, hint, err instanceof Error ? err : undefined);
+        },
+        backupPath: getAccountsBackupPath(path),
+        createTempPath: () => `${path}.${Date.now()}.${Math.random().toString(36).slice(2, 8)}.tmp`,
+    });
 }
-function cloneAccountStorageForPersistence(storage) {
+function cloneFlaggedStorageForPersistence(storage) {
     return {
-        version: 3,
+        version: 1,
         accounts: structuredClone(storage?.accounts ?? []),
-        activeIndex: typeof storage?.activeIndex === "number" &&
-            Number.isFinite(storage.activeIndex)
-            ? storage.activeIndex
-            : 0,
-        activeIndexByFamily: structuredClone(storage?.activeIndexByFamily ?? {}),
     };
 }
 export async function withAccountStorageTransaction(handler) {
-    return withStorageLock(async () => {
-        const state = {
-            snapshot: await loadAccountsInternal(saveAccountsUnlocked),
-            active: true,
-        };
-        const current = state.snapshot;
-        const persist = async (storage) => {
-            await saveAccountsUnlocked(storage);
-            state.snapshot = storage;
-        };
-        return transactionSnapshotContext.run(state, () => handler(current, persist));
+    return runWithAccountStorageTransaction(handler, {
+        getStoragePath,
+        loadCurrent: () => loadAccountsInternal(saveAccountsUnlocked),
+        saveAccounts: saveAccountsUnlocked,
     });
 }
 export async function withAccountAndFlaggedStorageTransaction(handler) {
     return withStorageLock(async () => {
+        const storagePath = getStoragePath();
         const state = {
             snapshot: await loadAccountsInternal(saveAccountsUnlocked),
+            storagePath,
             active: true,
         };
         const current = state.snapshot;
+        const currentFlagged = await loadFlaggedAccounts();
         const persist = async (accountStorage, flaggedStorage) => {
             const previousAccounts = cloneAccountStorageForPersistence(state.snapshot);
             const nextAccounts = cloneAccountStorageForPersistence(accountStorage);
+            const nextFlagged = cloneFlaggedStorageForPersistence(flaggedStorage);
             await saveAccountsUnlocked(nextAccounts);
             try {
-                await saveFlaggedAccountsUnlocked(flaggedStorage);
+                await saveFlaggedAccountsUnlocked(nextFlagged);
                 state.snapshot = nextAccounts;
             }
             catch (error) {
@@ -1480,7 +1272,37 @@ export async function withAccountAndFlaggedStorageTransaction(handler) {
                 throw error;
             }
         };
-        return transactionSnapshotContext.run(state, () => handler(current, persist));
+        return runInTransactionSnapshotContext(state, () => handler(current, persist, currentFlagged));
+    });
+}
+export async function withFlaggedStorageTransaction(handler) {
+    return withStorageLock(async () => {
+        const current = await loadFlaggedAccounts();
+        let snapshot = cloneFlaggedStorageForPersistence(current);
+        const persist = async (storage) => {
+            const previousStorage = cloneFlaggedStorageForPersistence(snapshot);
+            const nextStorage = cloneFlaggedStorageForPersistence(storage);
+            try {
+                await saveFlaggedAccountsUnlocked(nextStorage);
+                snapshot = nextStorage;
+            }
+            catch (error) {
+                try {
+                    await saveFlaggedAccountsUnlocked(previousStorage);
+                    snapshot = previousStorage;
+                }
+                catch (rollbackError) {
+                    const combinedError = new AggregateError([error, rollbackError], "Flagged save failed and flagged storage rollback also failed");
+                    log.error("Failed to rollback flagged storage after flagged save failure", {
+                        error: String(error),
+                        rollbackError: String(rollbackError),
+                    });
+                    throw combinedError;
+                }
+                throw error;
+            }
+        };
+        return handler(structuredClone(snapshot), persist);
     });
 }
 /**
@@ -1491,8 +1313,10 @@ export async function withAccountAndFlaggedStorageTransaction(handler) {
  * @throws StorageError with platform-aware hints on failure
  */
 export async function saveAccounts(storage) {
-    return withStorageLock(async () => {
-        await saveAccountsUnlocked(storage);
+    return saveAccountsEntry({
+        storage,
+        withStorageLock,
+        saveUnlocked: saveAccountsUnlocked,
     });
 }
 /**
@@ -1500,265 +1324,75 @@ export async function saveAccounts(storage) {
  * Silently ignores if file doesn't exist.
  */
 export async function clearAccounts() {
-    return withStorageLock(async () => {
-        const path = getStoragePath();
-        const resetMarkerPath = getIntentionalResetMarkerPath(path);
-        const walPath = getAccountsWalPath(path);
-        const backupPaths = await getAccountsBackupRecoveryCandidatesWithDiscovery(path);
-        await fs.writeFile(resetMarkerPath, JSON.stringify({ version: 1, createdAt: Date.now() }), { encoding: "utf-8", mode: 0o600 });
-        const clearPath = async (targetPath) => {
-            try {
-                await fs.unlink(targetPath);
-            }
-            catch (error) {
-                const code = error.code;
-                if (code !== "ENOENT") {
-                    log.error("Failed to clear account storage artifact", {
-                        path: targetPath,
-                        error: String(error),
-                    });
-                }
-            }
-        };
-        try {
-            await Promise.all([
-                clearPath(path),
-                clearPath(walPath),
-                ...backupPaths.map(clearPath),
-            ]);
-        }
-        catch {
-            // Individual path cleanup is already best-effort with per-artifact logging.
-        }
+    const path = getStoragePath();
+    return clearAccountsEntry({
+        path,
+        withStorageLock,
+        resetMarkerPath: getIntentionalResetMarkerPath(path),
+        walPath: getAccountsWalPath(path),
+        getBackupPaths: () => getAccountsBackupRecoveryCandidatesWithDiscovery(path),
+        clearAccountStorageArtifacts,
+        logError: (message, details) => {
+            log.error(message, details);
+        },
     });
 }
-function normalizeFlaggedStorage(data) {
-    if (!isRecord(data) || data.version !== 1 || !Array.isArray(data.accounts)) {
-        return { version: 1, accounts: [] };
-    }
-    const byRefreshToken = new Map();
-    for (const rawAccount of data.accounts) {
-        if (!isRecord(rawAccount))
-            continue;
-        const refreshToken = typeof rawAccount.refreshToken === "string"
-            ? rawAccount.refreshToken.trim()
-            : "";
-        if (!refreshToken)
-            continue;
-        const flaggedAt = typeof rawAccount.flaggedAt === "number"
-            ? rawAccount.flaggedAt
-            : Date.now();
-        const isAccountIdSource = (value) => value === "token" ||
-            value === "id_token" ||
-            value === "org" ||
-            value === "manual";
-        const isSwitchReason = (value) => value === "rate-limit" ||
-            value === "initial" ||
-            value === "rotation" ||
-            value === "best";
-        const isCooldownReason = (value) => value === "auth-failure" ||
-            value === "network-error" ||
-            value === "rate-limit";
-        let rateLimitResetTimes;
-        if (isRecord(rawAccount.rateLimitResetTimes)) {
-            const normalizedRateLimits = {};
-            for (const [key, value] of Object.entries(rawAccount.rateLimitResetTimes)) {
-                if (typeof value === "number") {
-                    normalizedRateLimits[key] = value;
-                }
-            }
-            if (Object.keys(normalizedRateLimits).length > 0) {
-                rateLimitResetTimes = normalizedRateLimits;
-            }
-        }
-        const accountIdSource = isAccountIdSource(rawAccount.accountIdSource)
-            ? rawAccount.accountIdSource
-            : undefined;
-        const lastSwitchReason = isSwitchReason(rawAccount.lastSwitchReason)
-            ? rawAccount.lastSwitchReason
-            : undefined;
-        const cooldownReason = isCooldownReason(rawAccount.cooldownReason)
-            ? rawAccount.cooldownReason
-            : undefined;
-        const normalized = {
-            refreshToken,
-            addedAt: typeof rawAccount.addedAt === "number" ? rawAccount.addedAt : flaggedAt,
-            lastUsed: typeof rawAccount.lastUsed === "number"
-                ? rawAccount.lastUsed
-                : flaggedAt,
-            accountId: typeof rawAccount.accountId === "string"
-                ? rawAccount.accountId
-                : undefined,
-            accountIdSource,
-            accountLabel: typeof rawAccount.accountLabel === "string"
-                ? rawAccount.accountLabel
-                : undefined,
-            email: typeof rawAccount.email === "string" ? rawAccount.email : undefined,
-            enabled: typeof rawAccount.enabled === "boolean"
-                ? rawAccount.enabled
-                : undefined,
-            lastSwitchReason,
-            rateLimitResetTimes,
-            coolingDownUntil: typeof rawAccount.coolingDownUntil === "number"
-                ? rawAccount.coolingDownUntil
-                : undefined,
-            cooldownReason,
-            flaggedAt,
-            flaggedReason: typeof rawAccount.flaggedReason === "string"
-                ? rawAccount.flaggedReason
-                : undefined,
-            lastError: typeof rawAccount.lastError === "string"
-                ? rawAccount.lastError
-                : undefined,
-        };
-        byRefreshToken.set(refreshToken, normalized);
-    }
-    return {
-        version: 1,
-        accounts: Array.from(byRefreshToken.values()),
-    };
-}
 export async function loadFlaggedAccounts() {
-    const path = getFlaggedAccountsPath();
-    const resetMarkerPath = getIntentionalResetMarkerPath(path);
-    const empty = { version: 1, accounts: [] };
-    try {
-        const content = await fs.readFile(path, "utf-8");
-        const data = JSON.parse(content);
-        const loaded = normalizeFlaggedStorage(data);
-        if (existsSync(resetMarkerPath)) {
-            return empty;
-        }
-        return loaded;
-    }
-    catch (error) {
-        const code = error.code;
-        if (code !== "ENOENT") {
-            log.error("Failed to load flagged account storage", {
-                path,
-                error: String(error),
-            });
-            return empty;
-        }
-    }
-    const legacyPath = getLegacyFlaggedAccountsPath();
-    if (!existsSync(legacyPath)) {
-        return empty;
-    }
-    try {
-        const legacyContent = await fs.readFile(legacyPath, "utf-8");
-        const legacyData = JSON.parse(legacyContent);
-        const migrated = normalizeFlaggedStorage(legacyData);
-        if (migrated.accounts.length > 0) {
-            await saveFlaggedAccounts(migrated);
-        }
-        try {
-            await fs.unlink(legacyPath);
-        }
-        catch {
-            // Best effort cleanup.
-        }
-        log.info("Migrated legacy flagged account storage", {
-            from: legacyPath,
-            to: path,
-            accounts: migrated.accounts.length,
-        });
-        return migrated;
-    }
-    catch (error) {
-        log.error("Failed to migrate legacy flagged account storage", {
-            from: legacyPath,
-            to: path,
-            error: String(error),
-        });
-        return empty;
-    }
+    return loadFlaggedAccountsEntry({
+        getFlaggedAccountsPath,
+        getLegacyFlaggedAccountsPath,
+        getIntentionalResetMarkerPath,
+        normalizeFlaggedStorage: (data) => normalizeFlaggedStorage(data, {
+            isRecord,
+            now: () => Date.now(),
+        }),
+        saveFlaggedAccounts,
+        loadFlaggedAccountsState,
+        logError: (message, details) => {
+            log.error(message, details);
+        },
+        logInfo: (message, details) => {
+            log.info(message, details);
+        },
+    });
 }
 async function saveFlaggedAccountsUnlocked(storage) {
     const path = getFlaggedAccountsPath();
-    const markerPath = getIntentionalResetMarkerPath(path);
-    const uniqueSuffix = `${Date.now()}.${Math.random().toString(36).slice(2, 8)}`;
-    const tempPath = `${path}.${uniqueSuffix}.tmp`;
-    try {
-        await fs.mkdir(dirname(path), { recursive: true });
-        if (existsSync(path)) {
-            try {
-                await copyFileWithRetry(path, `${path}.bak`, {
-                    allowMissingSource: true,
-                });
-            }
-            catch (backupError) {
-                log.warn("Failed to create flagged backup snapshot", {
-                    path,
-                    error: String(backupError),
-                });
-            }
-        }
-        const content = JSON.stringify(normalizeFlaggedStorage(storage), null, 2);
-        await fs.writeFile(tempPath, content, { encoding: "utf-8", mode: 0o600 });
-        await renameFileWithRetry(tempPath, path);
-        try {
-            await fs.unlink(markerPath);
-        }
-        catch {
-            // Best effort cleanup.
-        }
-    }
-    catch (error) {
-        try {
-            await fs.unlink(tempPath);
-        }
-        catch {
-            // Ignore cleanup failures.
-        }
-        log.error("Failed to save flagged account storage", {
-            path,
-            error: String(error),
-        });
-        throw error;
-    }
+    return saveFlaggedAccountsUnlockedToDisk(storage, {
+        path,
+        markerPath: getIntentionalResetMarkerPath(path),
+        normalizeFlaggedStorage: (data) => normalizeFlaggedStorage(data, {
+            isRecord,
+            now: () => Date.now(),
+        }),
+        copyFileWithRetry,
+        renameFileWithRetry,
+        logWarn: (message, details) => {
+            log.warn(message, details);
+        },
+        logError: (message, details) => {
+            log.error(message, details);
+        },
+    });
 }
 export async function saveFlaggedAccounts(storage) {
-    return withStorageLock(async () => {
-        await saveFlaggedAccountsUnlocked(storage);
+    return saveFlaggedAccountsEntry({
+        storage,
+        withStorageLock,
+        saveUnlocked: saveFlaggedAccountsUnlocked,
     });
 }
 export async function clearFlaggedAccounts() {
-    return withStorageLock(async () => {
-        const path = getFlaggedAccountsPath();
-        const markerPath = getIntentionalResetMarkerPath(path);
-        try {
-            await fs.writeFile(markerPath, "reset", {
-                encoding: "utf-8",
-                mode: 0o600,
-            });
-        }
-        catch (error) {
-            log.error("Failed to write flagged reset marker", {
-                path,
-                markerPath,
-                error: String(error),
-            });
-            throw error;
-        }
-        const backupPaths = await getAccountsBackupRecoveryCandidatesWithDiscovery(path);
-        for (const candidate of [path, ...backupPaths, markerPath]) {
-            try {
-                await fs.unlink(candidate);
-            }
-            catch (error) {
-                const code = error.code;
-                if (code !== "ENOENT") {
-                    log.error("Failed to clear flagged account storage", {
-                        path: candidate,
-                        error: String(error),
-                    });
-                    if (candidate === path) {
-                        throw error;
-                    }
-                }
-            }
-        }
+    const path = getFlaggedAccountsPath();
+    return clearFlaggedAccountsEntry({
+        path,
+        withStorageLock,
+        markerPath: getIntentionalResetMarkerPath(path),
+        getBackupPaths: () => getAccountsBackupRecoveryCandidatesWithDiscovery(path),
+        clearFlaggedAccountsOnDisk,
+        logError: (message, details) => {
+            log.error(message, details);
+        },
     });
 }
 /**
@@ -1769,31 +1403,19 @@ export async function clearFlaggedAccounts() {
  */
 export async function exportAccounts(filePath, force = true, beforeCommit) {
     const resolvedPath = resolvePath(filePath);
-    if (!force && existsSync(resolvedPath)) {
-        throw new Error(`File already exists: ${resolvedPath}`);
-    }
-    const transactionState = transactionSnapshotContext.getStore();
-    const storage = transactionState?.active
-        ? transactionState.snapshot
-        : await withAccountStorageTransaction((current) => Promise.resolve(current));
-    if (!storage || storage.accounts.length === 0) {
-        throw new Error("No accounts to export");
-    }
-    await fs.mkdir(dirname(resolvedPath), { recursive: true });
-    await beforeCommit?.(resolvedPath);
-    if (!force && existsSync(resolvedPath)) {
-        throw new Error(`File already exists: ${resolvedPath}`);
-    }
-    const content = JSON.stringify({
-        version: storage.version,
-        accounts: storage.accounts,
-        activeIndex: storage.activeIndex,
-        activeIndexByFamily: storage.activeIndexByFamily,
-    }, null, 2);
-    await fs.writeFile(resolvedPath, content, { encoding: "utf-8", mode: 0o600 });
-    log.info("Exported accounts", {
-        path: resolvedPath,
-        count: storage.accounts.length,
+    const currentStoragePath = getStoragePath();
+    await exportAccountsSnapshot({
+        resolvedPath,
+        force,
+        currentStoragePath,
+        transactionState: getTransactionSnapshotState(),
+        readCurrentStorageUnlocked: () => loadAccountsForExport(),
+        readCurrentStorage: () => withStorageLock(() => loadAccountsForExport()),
+        exportAccountsToFile,
+        beforeCommit,
+        logInfo: (message, details) => {
+            log.info(message, details);
+        },
     });
 }
 /**
@@ -1804,50 +1426,17 @@ export async function exportAccounts(filePath, force = true, beforeCommit) {
  */
 export async function importAccounts(filePath) {
     const resolvedPath = resolvePath(filePath);
-    // Check file exists with friendly error
-    if (!existsSync(resolvedPath)) {
-        throw new Error(`Import file not found: ${resolvedPath}`);
-    }
-    const content = await fs.readFile(resolvedPath, "utf-8");
-    let imported;
-    try {
-        imported = JSON.parse(content);
-    }
-    catch {
-        throw new Error(`Invalid JSON in import file: ${resolvedPath}`);
-    }
-    const normalized = normalizeAccountStorage(imported);
-    if (!normalized) {
-        throw new Error("Invalid account storage format");
-    }
-    const { imported: importedCount, total, skipped: skippedCount, } = await withAccountStorageTransaction(async (existing, persist) => {
-        const existingAccounts = existing?.accounts ?? [];
-        const existingActiveIndex = existing?.activeIndex ?? 0;
-        const merged = [...existingAccounts, ...normalized.accounts];
-        if (merged.length > ACCOUNT_LIMITS.MAX_ACCOUNTS) {
-            const deduped = deduplicateAccounts(merged);
-            if (deduped.length > ACCOUNT_LIMITS.MAX_ACCOUNTS) {
-                throw new Error(`Import would exceed maximum of ${ACCOUNT_LIMITS.MAX_ACCOUNTS} accounts (would have ${deduped.length})`);
-            }
-        }
-        const deduplicatedAccounts = deduplicateAccounts(merged);
-        const newStorage = {
-            version: 3,
-            accounts: deduplicatedAccounts,
-            activeIndex: existingActiveIndex,
-            activeIndexByFamily: existing?.activeIndexByFamily,
-        };
-        await persist(newStorage);
-        const imported = deduplicatedAccounts.length - existingAccounts.length;
-        const skipped = normalized.accounts.length - imported;
-        return { imported, total: deduplicatedAccounts.length, skipped };
-    });
-    log.info("Imported accounts", {
-        path: resolvedPath,
-        imported: importedCount,
-        skipped: skippedCount,
-        total,
+    return importAccountsSnapshot({
+        resolvedPath,
+        readImportFile,
+        normalizeAccountStorage,
+        withAccountStorageTransaction,
+        mergeImportedAccounts,
+        maxAccounts: ACCOUNT_LIMITS.MAX_ACCOUNTS,
+        deduplicateAccounts,
+        logInfo: (message, details) => {
+            log.info(message, details);
+        },
     });
-    return { imported: importedCount, total, skipped: skippedCount };
 }
 //# sourceMappingURL=storage.js.map