flawed-avatar 0.2.1

package/dist/main/main/persistence/file-store.js

@@ -0,0 +1,183 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { SETTINGS_DEBOUNCE_MS, LOCK_TIMEOUT_MS, LOCK_STALE_MS, } from "../../shared/config.js";
+const openclawDir = path.join(os.homedir(), ".openclaw");
+function ensureDir() {
+    try {
+        fs.mkdirSync(openclawDir, { recursive: true });
+    }
+    catch {
+        // Directory likely already exists
+    }
+}
+function getLockPath(filePath) {
+    return `${filePath}.lock`;
+}
+function acquireLock(filePath) {
+    const lockPath = getLockPath(filePath);
+    try {
+        // Check for stale lock
+        try {
+            const stat = fs.statSync(lockPath);
+            const age = Date.now() - stat.mtimeMs;
+            if (age > LOCK_STALE_MS) {
+                // Lock is stale, remove it
+                fs.unlinkSync(lockPath);
+            }
+        }
+        catch {
+            // Lock doesn't exist, good
+        }
+        // Try to create lock file exclusively
+        fs.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function releaseLock(filePath) {
+    const lockPath = getLockPath(filePath);
+    try {
+        fs.unlinkSync(lockPath);
+    }
+    catch {
+        // Lock already released or never acquired
+    }
+}
+async function waitForLock(filePath, timeoutMs = LOCK_TIMEOUT_MS) {
+    const startTime = Date.now();
+    const interval = 50;
+    while (Date.now() - startTime < timeoutMs) {
+        if (acquireLock(filePath)) {
+            return true;
+        }
+        await new Promise((resolve) => setTimeout(resolve, interval));
+    }
+    return false;
+}
+export function createFileStore(options) {
+    const { filename, schema, defaultValue, debounceMs = SETTINGS_DEBOUNCE_MS } = options;
+    const filePath = path.join(openclawDir, filename);
+    let cache = null;
+    let pendingData = null;
+    let saveTimeout = null;
+    let isFlushing = false;
+    function load() {
+        try {
+            const data = fs.readFileSync(filePath, "utf-8");
+            const parsed = JSON.parse(data);
+            const result = schema.safeParse(parsed);
+            if (result.success) {
+                cache = result.data;
+                return { ok: true, data: result.data };
+            }
+            // Schema validation failed
+            console.warn(`[file-store] Schema validation failed for ${filename}:`, result.error.message);
+            const fallback = defaultValue();
+            cache = fallback;
+            return { ok: false, error: result.error.message, fallback };
+        }
+        catch (err) {
+            // File not found or parse error - normal for first run
+            const fallback = defaultValue();
+            cache = fallback;
+            if (err.code !== "ENOENT") {
+                console.warn(`[file-store] Error reading ${filename}:`, err);
+                return { ok: false, error: String(err), fallback };
+            }
+            return { ok: true, data: fallback };
+        }
+    }
+    function scheduleWrite(data) {
+        pendingData = data;
+        cache = data;
+        if (saveTimeout) {
+            clearTimeout(saveTimeout);
+        }
+        saveTimeout = setTimeout(() => {
+            void performWrite();
+        }, debounceMs);
+    }
+    async function performWrite() {
+        if (pendingData === null || isFlushing)
+            return;
+        isFlushing = true;
+        const dataToWrite = pendingData;
+        pendingData = null;
+        saveTimeout = null;
+        const lockAcquired = await waitForLock(filePath);
+        if (!lockAcquired) {
+            console.warn(`[file-store] Failed to acquire lock for ${filename}, will retry on next save`);
+            pendingData = dataToWrite; // Restore pending data for retry
+            isFlushing = false;
+            return;
+        }
+        try {
+            ensureDir();
+            // On Windows, atomic rename doesn't work well across drives,
+            // so we write directly
+            const content = JSON.stringify(dataToWrite, null, "\t");
+            if (process.platform === "win32") {
+                fs.writeFileSync(filePath, content);
+            }
+            else {
+                // Atomic write: temp file + rename
+                const tempPath = `${filePath}.tmp.${process.pid}`;
+                fs.writeFileSync(tempPath, content);
+                fs.renameSync(tempPath, filePath);
+            }
+        }
+        catch (err) {
+            console.warn(`[file-store] Error writing ${filename}:`, err);
+        }
+        finally {
+            releaseLock(filePath);
+            isFlushing = false;
+        }
+    }
+    function save(data) {
+        scheduleWrite(data);
+    }
+    async function flush() {
+        if (saveTimeout) {
+            clearTimeout(saveTimeout);
+            saveTimeout = null;
+        }
+        if (pendingData !== null) {
+            await performWrite();
+        }
+    }
+    function getCache() {
+        return cache;
+    }
+    function cleanup() {
+        if (saveTimeout) {
+            clearTimeout(saveTimeout);
+            saveTimeout = null;
+        }
+        // Synchronous flush on cleanup
+        if (pendingData !== null) {
+            try {
+                ensureDir();
+                const content = JSON.stringify(pendingData, null, "\t");
+                fs.writeFileSync(filePath, content);
+            }
+            catch {
+                // Ignore errors during cleanup
+            }
+            pendingData = null;
+        }
+    }
+    return {
+        load,
+        save,
+        flush,
+        getCache,
+        cleanup,
+    };
+}
+export function getOpenclawDir() {
+    return openclawDir;
+}

package/dist/main/main/persistence/index.d.ts

@@ -0,0 +1,8 @@
+export type { Settings, ChatMessage, ChatHistory, LoadResult, } from "./types.js";
+export type { LightingCustom } from "./types.js";
+export { SETTINGS_SCHEMA_VERSION, CHAT_SCHEMA_VERSION, SettingsSchema, LightingCustomSchema, ChatMessageSchema, ChatHistorySchema, createDefaultSettings, createDefaultChatHistory, } from "./types.js";
+export type { FileStore, StoreOptions } from "./file-store.js";
+export { createFileStore, getOpenclawDir } from "./file-store.js";
+export { loadSettings, saveSettings, savePosition, saveZoom, saveOpacity, saveIdleTimeout, saveTtsEnabled, saveTtsEngine, saveTtsVoice, saveVrmModelPath, getPosition, getZoom, getOpacity, getIdleTimeout, getTtsEnabled, getTtsEngine, getTtsVoice, getVrmModelPath, saveScale, getScale, saveLightingProfile, getLightingProfile, saveLightingCustom, getLightingCustom, flushSettings, cleanupSettings, getSettingsStore, } from "./settings-store.js";
+export { loadChatHistory, appendMessage, clearChatHistory, getRecentMessages, getChatHistory, flushChat, cleanupChat, } from "./chat-store.js";
+export { migrateFileNames, migrateLegacyFiles, migrateV1ToV2, migrateV2ToV3 } from "./migrations.js";

package/dist/main/main/persistence/index.js

@@ -0,0 +1,8 @@
+export { SETTINGS_SCHEMA_VERSION, CHAT_SCHEMA_VERSION, SettingsSchema, LightingCustomSchema, ChatMessageSchema, ChatHistorySchema, createDefaultSettings, createDefaultChatHistory, } from "./types.js";
+export { createFileStore, getOpenclawDir } from "./file-store.js";
+// Settings store
+export { loadSettings, saveSettings, savePosition, saveZoom, saveOpacity, saveIdleTimeout, saveTtsEnabled, saveTtsEngine, saveTtsVoice, saveVrmModelPath, getPosition, getZoom, getOpacity, getIdleTimeout, getTtsEnabled, getTtsEngine, getTtsVoice, getVrmModelPath, saveScale, getScale, saveLightingProfile, getLightingProfile, saveLightingCustom, getLightingCustom, flushSettings, cleanupSettings, getSettingsStore, } from "./settings-store.js";
+// Chat store
+export { loadChatHistory, appendMessage, clearChatHistory, getRecentMessages, getChatHistory, flushChat, cleanupChat, } from "./chat-store.js";
+// Migrations
+export { migrateFileNames, migrateLegacyFiles, migrateV1ToV2, migrateV2ToV3 } from "./migrations.js";

package/dist/main/main/persistence/migrations.d.ts

@@ -0,0 +1,23 @@
+import { type Settings } from "./types.js";
+/**
+ * Renames old avatar-overlay-*.json files to flawed-avatar-*.json
+ * so existing users' settings survive the package rename.
+ */
+export declare function migrateFileNames(): void;
+/**
+ * Migrates legacy separate files (position.json, camera.json) to unified settings.
+ * Returns the migrated settings if migration occurred, null otherwise.
+ * Safe to call multiple times - only migrates if legacy files exist.
+ */
+export declare function migrateLegacyFiles(): Settings | null;
+/**
+ * Migrates settings from schema v1 to v2.
+ * Converts position from `{x,y}` flat object to `Record<displayHash, {x,y}>`.
+ * Reads raw JSON to avoid schema validation rejecting the old format.
+ */
+export declare function migrateV1ToV2(): void;
+/**
+ * Migrates settings from schema v2 to v3.
+ * Adds `scale` and `lightingProfile` fields with defaults.
+ */
+export declare function migrateV2ToV3(): void;

package/dist/main/main/persistence/migrations.js

@@ -0,0 +1,191 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { WINDOW_POSITION_FILE, CAMERA_ZOOM_FILE, CAMERA_ZOOM_MIN, CAMERA_ZOOM_MAX, SCALE_DEFAULT, LIGHTING_PROFILE_DEFAULT, } from "../../shared/config.js";
+import { getOpenclawDir } from "./file-store.js";
+import { createDefaultSettings, SETTINGS_SCHEMA_VERSION, } from "./types.js";
+import { loadSettings, getSettingsStore } from "./settings-store.js";
+import { computeDisplayHash } from "../display-utils.js";
+/**
+ * Renames old avatar-overlay-*.json files to flawed-avatar-*.json
+ * so existing users' settings survive the package rename.
+ */
+export function migrateFileNames() {
+    const dir = getOpenclawDir();
+    const renames = [
+        ["avatar-overlay-settings.json", "flawed-avatar-settings.json"],
+        ["avatar-overlay-position.json", "flawed-avatar-position.json"],
+        ["avatar-overlay-camera.json", "flawed-avatar-camera.json"],
+        ["avatar-overlay-chat.json", "flawed-avatar-chat.json"],
+    ];
+    for (const [oldName, newName] of renames) {
+        const oldPath = path.join(dir, oldName);
+        const newPath = path.join(dir, newName);
+        try {
+            if (fs.existsSync(oldPath) && !fs.existsSync(newPath)) {
+                fs.renameSync(oldPath, newPath);
+                console.log(`[migrations] Renamed ${oldName} → ${newName}`);
+            }
+        }
+        catch {
+            // Best-effort; next run will retry
+        }
+    }
+}
+function readLegacyPosition() {
+    const filePath = path.join(getOpenclawDir(), WINDOW_POSITION_FILE);
+    try {
+        const data = fs.readFileSync(filePath, "utf-8");
+        const parsed = JSON.parse(data);
+        if (typeof parsed.x === "number" &&
+            typeof parsed.y === "number" &&
+            Number.isFinite(parsed.x) &&
+            Number.isFinite(parsed.y)) {
+            return { x: parsed.x, y: parsed.y };
+        }
+    }
+    catch {
+        // File doesn't exist or is invalid
+    }
+    return null;
+}
+function readLegacyCamera() {
+    const filePath = path.join(getOpenclawDir(), CAMERA_ZOOM_FILE);
+    try {
+        const data = fs.readFileSync(filePath, "utf-8");
+        const parsed = JSON.parse(data);
+        if (typeof parsed.zoom === "number" &&
+            Number.isFinite(parsed.zoom) &&
+            parsed.zoom >= CAMERA_ZOOM_MIN &&
+            parsed.zoom <= CAMERA_ZOOM_MAX) {
+            return { zoom: parsed.zoom };
+        }
+    }
+    catch {
+        // File doesn't exist or is invalid
+    }
+    return null;
+}
+function deleteLegacyFile(filename) {
+    const filePath = path.join(getOpenclawDir(), filename);
+    try {
+        fs.unlinkSync(filePath);
+        console.log(`[migrations] Deleted legacy file: ${filename}`);
+    }
+    catch {
+        // File doesn't exist or can't be deleted
+    }
+}
+/**
+ * Migrates legacy separate files (position.json, camera.json) to unified settings.
+ * Returns the migrated settings if migration occurred, null otherwise.
+ * Safe to call multiple times - only migrates if legacy files exist.
+ */
+export function migrateLegacyFiles() {
+    const legacyPosition = readLegacyPosition();
+    const legacyCamera = readLegacyCamera();
+    // No legacy files to migrate
+    if (!legacyPosition && !legacyCamera) {
+        return null;
+    }
+    console.log("[migrations] Found legacy settings files, migrating...");
+    // Load current settings (may be defaults if new install)
+    const current = loadSettings();
+    // Build migrated settings
+    const migrated = {
+        ...createDefaultSettings(),
+        ...current,
+        schemaVersion: SETTINGS_SCHEMA_VERSION,
+    };
+    // Only migrate position if not already set in new format
+    if (legacyPosition && (!current.position || Object.keys(current.position).length === 0)) {
+        const hash = computeDisplayHash();
+        migrated.position = { [hash]: legacyPosition };
+        console.log(`[migrations] Migrated position: (${legacyPosition.x}, ${legacyPosition.y}) for display ${hash}`);
+    }
+    // Only migrate camera if not already set in new format
+    if (legacyCamera && !current.camera) {
+        migrated.camera = { zoom: legacyCamera.zoom };
+        console.log(`[migrations] Migrated camera zoom: ${legacyCamera.zoom}`);
+    }
+    // Save migrated settings
+    getSettingsStore().save(migrated);
+    // Delete legacy files after successful migration
+    if (legacyPosition) {
+        deleteLegacyFile(WINDOW_POSITION_FILE);
+    }
+    if (legacyCamera) {
+        deleteLegacyFile(CAMERA_ZOOM_FILE);
+    }
+    console.log("[migrations] Migration complete");
+    return migrated;
+}
+/**
+ * Migrates settings from schema v1 to v2.
+ * Converts position from `{x,y}` flat object to `Record<displayHash, {x,y}>`.
+ * Reads raw JSON to avoid schema validation rejecting the old format.
+ */
+export function migrateV1ToV2() {
+    const filePath = path.join(getOpenclawDir(), "flawed-avatar-settings.json");
+    let raw;
+    try {
+        raw = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    }
+    catch {
+        return; // No settings file yet
+    }
+    // Already at v2 or newer
+    if (typeof raw.schemaVersion === "number" && raw.schemaVersion >= 2)
+        return;
+    // Check if position is old v1 format ({x, y} directly)
+    const pos = raw.position;
+    if (pos &&
+        typeof pos === "object" &&
+        !Array.isArray(pos) &&
+        "x" in pos &&
+        "y" in pos) {
+        const oldPos = pos;
+        const hash = computeDisplayHash();
+        console.log(`[migrations] Converting v1 position to v2 keyed by display hash ${hash}`);
+        raw.position = { [hash]: { x: oldPos.x, y: oldPos.y } };
+    }
+    raw.schemaVersion = 2;
+    try {
+        fs.writeFileSync(filePath, JSON.stringify(raw, null, "\t"));
+        console.log("[migrations] Schema upgraded to v2");
+    }
+    catch (err) {
+        console.warn("[migrations] Failed to write v2 migration:", err);
+    }
+}
+/**
+ * Migrates settings from schema v2 to v3.
+ * Adds `scale` and `lightingProfile` fields with defaults.
+ */
+export function migrateV2ToV3() {
+    const filePath = path.join(getOpenclawDir(), "flawed-avatar-settings.json");
+    let raw;
+    try {
+        raw = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    }
+    catch {
+        return; // No settings file yet
+    }
+    // Already at v3 or newer
+    if (typeof raw.schemaVersion === "number" && raw.schemaVersion >= 3)
+        return;
+    // Add defaults for new fields
+    if (raw.scale === undefined) {
+        raw.scale = SCALE_DEFAULT;
+    }
+    if (raw.lightingProfile === undefined) {
+        raw.lightingProfile = LIGHTING_PROFILE_DEFAULT;
+    }
+    raw.schemaVersion = SETTINGS_SCHEMA_VERSION;
+    try {
+        fs.writeFileSync(filePath, JSON.stringify(raw, null, "\t"));
+        console.log("[migrations] Schema upgraded to v3");
+    }
+    catch (err) {
+        console.warn("[migrations] Failed to write v3 migration:", err);
+    }
+}

package/dist/main/main/persistence/settings-store.d.ts

@@ -0,0 +1,32 @@
+import { type FileStore } from "./file-store.js";
+import { type Settings, type LightingCustom } from "./types.js";
+export declare function loadSettings(): Settings;
+export declare function saveSettings(settings: Partial<Settings>): void;
+export declare function savePosition(x: number, y: number): void;
+export declare function saveZoom(zoom: number): void;
+export declare function saveOpacity(opacity: number): void;
+export declare function saveIdleTimeout(ms: number): void;
+export declare function getPosition(): {
+    x: number;
+    y: number;
+} | null;
+export declare function getZoom(): number;
+export declare function getOpacity(): number;
+export declare function getIdleTimeout(): number;
+export declare function saveTtsEnabled(enabled: boolean): void;
+export declare function getTtsEnabled(): boolean;
+export declare function saveTtsEngine(engine: "web-speech" | "kokoro"): void;
+export declare function getTtsEngine(): "web-speech" | "kokoro";
+export declare function saveTtsVoice(voice: string): void;
+export declare function getTtsVoice(): string;
+export declare function saveVrmModelPath(path: string): void;
+export declare function getVrmModelPath(): string | undefined;
+export declare function saveScale(scale: number): void;
+export declare function getScale(): number;
+export declare function saveLightingProfile(profile: string): void;
+export declare function getLightingProfile(): string;
+export declare function saveLightingCustom(custom: LightingCustom): void;
+export declare function getLightingCustom(): LightingCustom | undefined;
+export declare function flushSettings(): Promise<void>;
+export declare function cleanupSettings(): void;
+export declare function getSettingsStore(): FileStore<Settings>;

package/dist/main/main/persistence/settings-store.js

@@ -0,0 +1,174 @@
+import { SETTINGS_FILE, CAMERA_ZOOM_MIN, CAMERA_ZOOM_MAX, CAMERA_ZOOM_DEFAULT, OPACITY_MIN, OPACITY_MAX, OPACITY_DEFAULT, IDLE_TIMEOUT_DEFAULT, SETTINGS_DEBOUNCE_MS, TTS_ENABLED_DEFAULT, TTS_ENGINE_DEFAULT, TTS_VOICE_DEFAULT, SCALE_MIN, SCALE_MAX, SCALE_DEFAULT, LIGHTING_PROFILE_DEFAULT, } from "../../shared/config.js";
+import { createFileStore } from "./file-store.js";
+import { SettingsSchema, createDefaultSettings, } from "./types.js";
+import { computeDisplayHash } from "../display-utils.js";
+let store = null;
+function getStore() {
+    if (!store) {
+        store = createFileStore({
+            filename: SETTINGS_FILE,
+            schema: SettingsSchema,
+            defaultValue: createDefaultSettings,
+            debounceMs: SETTINGS_DEBOUNCE_MS,
+        });
+    }
+    return store;
+}
+export function loadSettings() {
+    const result = getStore().load();
+    return result.ok ? result.data : result.fallback;
+}
+export function saveSettings(settings) {
+    const current = getStore().getCache() ?? loadSettings();
+    const updated = { ...current, ...settings };
+    getStore().save(updated);
+}
+export function savePosition(x, y) {
+    if (!Number.isFinite(x) || !Number.isFinite(y))
+        return;
+    const hash = computeDisplayHash();
+    const current = getStore().getCache() ?? loadSettings();
+    const positions = { ...current.position };
+    positions[hash] = { x: Math.round(x), y: Math.round(y) };
+    const updated = { ...current, position: positions };
+    getStore().save(updated);
+}
+export function saveZoom(zoom) {
+    if (!Number.isFinite(zoom))
+        return;
+    const clamped = Math.max(CAMERA_ZOOM_MIN, Math.min(CAMERA_ZOOM_MAX, zoom));
+    const current = getStore().getCache() ?? loadSettings();
+    const updated = {
+        ...current,
+        camera: { zoom: clamped },
+    };
+    getStore().save(updated);
+}
+export function saveOpacity(opacity) {
+    if (!Number.isFinite(opacity))
+        return;
+    const clamped = Math.max(OPACITY_MIN, Math.min(OPACITY_MAX, opacity));
+    const current = getStore().getCache() ?? loadSettings();
+    const updated = {
+        ...current,
+        opacity: clamped,
+    };
+    getStore().save(updated);
+}
+export function saveIdleTimeout(ms) {
+    if (!Number.isInteger(ms) || ms < 0)
+        return;
+    const current = getStore().getCache() ?? loadSettings();
+    const updated = {
+        ...current,
+        idleTimeoutMs: ms,
+    };
+    getStore().save(updated);
+}
+export function getPosition() {
+    const settings = getStore().getCache() ?? loadSettings();
+    if (!settings.position)
+        return null;
+    const hash = computeDisplayHash();
+    return settings.position[hash] ?? null;
+}
+export function getZoom() {
+    const settings = getStore().getCache() ?? loadSettings();
+    return settings.camera?.zoom ?? CAMERA_ZOOM_DEFAULT;
+}
+export function getOpacity() {
+    const settings = getStore().getCache() ?? loadSettings();
+    return settings.opacity ?? OPACITY_DEFAULT;
+}
+export function getIdleTimeout() {
+    const settings = getStore().getCache() ?? loadSettings();
+    return settings.idleTimeoutMs ?? IDLE_TIMEOUT_DEFAULT;
+}
+export function saveTtsEnabled(enabled) {
+    const current = getStore().getCache() ?? loadSettings();
+    const updated = {
+        ...current,
+        ttsEnabled: enabled,
+    };
+    getStore().save(updated);
+}
+export function getTtsEnabled() {
+    const settings = getStore().getCache() ?? loadSettings();
+    return settings.ttsEnabled ?? TTS_ENABLED_DEFAULT;
+}
+export function saveTtsEngine(engine) {
+    const current = getStore().getCache() ?? loadSettings();
+    const updated = {
+        ...current,
+        ttsEngine: engine,
+    };
+    getStore().save(updated);
+}
+export function getTtsEngine() {
+    const settings = getStore().getCache() ?? loadSettings();
+    return settings.ttsEngine ?? TTS_ENGINE_DEFAULT;
+}
+export function saveTtsVoice(voice) {
+    const current = getStore().getCache() ?? loadSettings();
+    const updated = {
+        ...current,
+        ttsVoice: voice,
+    };
+    getStore().save(updated);
+}
+export function getTtsVoice() {
+    const settings = getStore().getCache() ?? loadSettings();
+    return settings.ttsVoice ?? TTS_VOICE_DEFAULT;
+}
+export function saveVrmModelPath(path) {
+    const current = getStore().getCache() ?? loadSettings();
+    const updated = {
+        ...current,
+        vrmModelPath: path,
+    };
+    getStore().save(updated);
+}
+export function getVrmModelPath() {
+    const settings = getStore().getCache() ?? loadSettings();
+    return settings.vrmModelPath;
+}
+export function saveScale(scale) {
+    if (!Number.isFinite(scale))
+        return;
+    const clamped = Math.max(SCALE_MIN, Math.min(SCALE_MAX, scale));
+    const current = getStore().getCache() ?? loadSettings();
+    const updated = { ...current, scale: clamped };
+    getStore().save(updated);
+}
+export function getScale() {
+    const settings = getStore().getCache() ?? loadSettings();
+    return settings.scale ?? SCALE_DEFAULT;
+}
+export function saveLightingProfile(profile) {
+    const current = getStore().getCache() ?? loadSettings();
+    const updated = { ...current, lightingProfile: profile };
+    getStore().save(updated);
+}
+export function getLightingProfile() {
+    const settings = getStore().getCache() ?? loadSettings();
+    return settings.lightingProfile ?? LIGHTING_PROFILE_DEFAULT;
+}
+export function saveLightingCustom(custom) {
+    const current = getStore().getCache() ?? loadSettings();
+    const updated = { ...current, lightingCustom: custom };
+    getStore().save(updated);
+}
+export function getLightingCustom() {
+    const settings = getStore().getCache() ?? loadSettings();
+    return settings.lightingCustom;
+}
+export async function flushSettings() {
+    await getStore().flush();
+}
+export function cleanupSettings() {
+    getStore().cleanup();
+}
+// For direct store access (e.g., migrations)
+export function getSettingsStore() {
+    return getStore();
+}