@vibesdotdev/account 0.0.0-stage → 1.0.0-rc.3

package/dist/svelte/runtime-log.js

@@ -0,0 +1,28 @@
+/**
+ * Logging for the Svelte surface: a component or store logs on the runtime it
+ * was handed, never the host default. The Svelte runtime store a component
+ * captured at init is the source: its `load()` yields the runtime the logger
+ * binds to.
+ */
+import { getLogger } from '@vibesdotdev/logging';
+import { settle, valueFreeFailure } from '@vibesdotdev/kernel';
+/**
+ * Log one entry on the runtime `source` holds. A source that never loaded has
+ * no runtime to bind a logger to, so the entry is dropped; the store records
+ * that failed load on its own `error`.
+ */
+export async function logOn(source, level, id, message, fields) {
+    const loaded = await settle(() => source.load());
+    if (!loaded.ok)
+        return;
+    getLogger(id, loaded.value)[level](message, fields);
+}
+/** Throw a captured failure again: the `Error` itself, or the non-Error value that was thrown. */
+export function rethrowFailure(failure) {
+    throw failure instanceof Error ? failure : failure.value;
+}
+/** The failure named by its value-free facts only (class, code, reason): safe in a log field. */
+export function failureLabel(failure) {
+    const facts = valueFreeFailure(failure);
+    return [facts.name, facts.code, facts.reason].filter((fact) => fact !== undefined).join(' ');
+}

package/dist/svelte/runtime.d.ts

@@ -0,0 +1,9 @@
+import { type RuntimeRef } from '@vibesdotdev/kernel';
+/**
+ * Derive the account-web origin from a theme stylesheet URL served by
+ * account-web (e.g. `https://account.vibes.dev/user/styles/theme.css`).
+ */
+export declare function accountOriginFromThemeStylesheet(themeStylesheetUrl?: string | null): string | null;
+/** Resolve account-web from an explicit theme URL or the handed runtime's environment. */
+export declare function getAccountOrigin(runtime: RuntimeRef, themeStylesheetUrl?: string | null): Promise<string>;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/svelte/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../src/svelte/runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAGvE;;;GAGG;AACH,wBAAgB,gCAAgC,CAAC,kBAAkB,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI,CAIlG;AAED,0FAA0F;AAC1F,wBAAsB,gBAAgB,CACrC,OAAO,EAAE,UAAU,EACnB,kBAAkB,CAAC,EAAE,MAAM,GAAG,IAAI,GAChC,OAAO,CAAC,MAAM,CAAC,CAWjB"}

package/dist/svelte/runtime.js

@@ -0,0 +1,25 @@
+import { CapabilityError } from '@vibesdotdev/kernel';
+import { resolveCatalogAccountOrigin, resolveLocalAccountOrigin } from "../config/origins.js";
+/**
+ * Derive the account-web origin from a theme stylesheet URL served by
+ * account-web (e.g. `https://account.vibes.dev/user/styles/theme.css`).
+ */
+export function accountOriginFromThemeStylesheet(themeStylesheetUrl) {
+    if (!themeStylesheetUrl)
+        return null;
+    const split = themeStylesheetUrl.split('/user/styles');
+    return split[0] ? split[0] : null;
+}
+/** Resolve account-web from an explicit theme URL or the handed runtime's environment. */
+export async function getAccountOrigin(runtime, themeStylesheetUrl) {
+    const fromStylesheet = accountOriginFromThemeStylesheet(themeStylesheetUrl);
+    if (fromStylesheet)
+        return fromStylesheet;
+    const origin = await resolveCatalogAccountOrigin(runtime);
+    if (origin)
+        return resolveLocalAccountOrigin(origin);
+    throw new CapabilityError('Account service origin is not declared in the runtime environment.', 'NOT_FOUND', {
+        reason: 'service-undeclared',
+        details: { serviceId: 'account' }
+    });
+}

package/dist/svelte/security.d.ts

@@ -0,0 +1,29 @@
+import type { AccountConnectedProvider } from '@vibesdotdev/account/api';
+export type AccountSecurityProvider = Pick<AccountConnectedProvider, 'providerId' | 'accountId'>;
+export interface AccountSecurityPosture {
+    hasPassword: boolean;
+    oauthProviders: AccountSecurityProvider[];
+    twoFactorEnabled: boolean;
+}
+export interface AccountSecurityAction {
+    id: string;
+    title: string;
+    description: string;
+    href: string;
+    actionLabel: string;
+    icon: string;
+    badge?: string;
+    external?: boolean;
+}
+export declare function deriveAccountSecurityPosture(input?: {
+    linkedProviders?: readonly AccountSecurityProvider[] | null;
+    twoFactorEnabled?: boolean | null;
+}): AccountSecurityPosture;
+export declare function createAccountSecurityActions(input: {
+    authOrigin?: string | null;
+    apiKeysHref?: string;
+    sessionsHref?: string;
+    connectedAccountsHref?: string;
+}): AccountSecurityAction[];
+export declare function summarizeOAuthProviders(providers: readonly AccountSecurityProvider[]): string;
+//# sourceMappingURL=security.d.ts.map

package/dist/svelte/security.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"security.d.ts","sourceRoot":"","sources":["../../src/svelte/security.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AAEzE,MAAM,MAAM,uBAAuB,GAAG,IAAI,CAAC,wBAAwB,EAAE,YAAY,GAAG,WAAW,CAAC,CAAC;AAEjG,MAAM,WAAW,sBAAsB;IACtC,WAAW,EAAE,OAAO,CAAC;IACrB,cAAc,EAAE,uBAAuB,EAAE,CAAC;IAC1C,gBAAgB,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,qBAAqB;IACrC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,wBAAgB,4BAA4B,CAC3C,KAAK,GAAE;IACN,eAAe,CAAC,EAAE,SAAS,uBAAuB,EAAE,GAAG,IAAI,CAAC;IAC5D,gBAAgB,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;CAC7B,GACJ,sBAAsB,CAOxB;AAED,wBAAgB,4BAA4B,CAAC,KAAK,EAAE;IACnD,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAC/B,GAAG,qBAAqB,EAAE,CAyD1B;AAED,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,SAAS,uBAAuB,EAAE,GAAG,MAAM,CAG7F"}

package/dist/svelte/security.js

@@ -0,0 +1,76 @@
+export function deriveAccountSecurityPosture(input = {}) {
+    const linkedProviders = input.linkedProviders ?? [];
+    return {
+        hasPassword: linkedProviders.some((provider) => provider.providerId === 'credential'),
+        oauthProviders: linkedProviders.filter((provider) => provider.providerId !== 'credential'),
+        twoFactorEnabled: input.twoFactorEnabled === true
+    };
+}
+export function createAccountSecurityActions(input) {
+    const authOrigin = trimTrailingSlash(input.authOrigin ?? '');
+    // auth-web routes (these MUST exist on auth-web). The old `/auth` and
+    // `/auth/email/password/forgot` targets never existed — they 404'd (#703).
+    const mfaHref = authOrigin ? `${authOrigin}/security/mfa` : '/security/mfa';
+    const passwordHref = authOrigin ? `${authOrigin}/forgot-password` : '/forgot-password';
+    return [
+        {
+            id: 'api-keys',
+            title: 'API Keys',
+            description: 'Create, rotate, and revoke keys for programmatic access.',
+            href: input.apiKeysHref ?? '/api-keys',
+            actionLabel: 'Manage API keys',
+            icon: 'lucide:key',
+            badge: 'Developer',
+            external: isExternalHref(input.apiKeysHref ?? '/api-keys')
+        },
+        {
+            id: 'sessions',
+            title: 'Active Sessions',
+            description: "Review where you're signed in and remotely revoke devices.",
+            href: input.sessionsHref ?? '/sessions',
+            actionLabel: 'Review sessions',
+            icon: 'lucide:monitor',
+            badge: 'Access'
+        },
+        {
+            id: 'password',
+            title: 'Password',
+            description: 'Reset or recover your email/password authentication method.',
+            href: passwordHref,
+            actionLabel: 'Reset password',
+            icon: 'lucide:key-round',
+            badge: 'Auth',
+            external: Boolean(authOrigin)
+        },
+        {
+            id: 'mfa',
+            title: 'Two-factor Authentication',
+            description: 'Manage MFA and backup-code protection for your account.',
+            href: mfaHref,
+            actionLabel: 'Manage MFA',
+            icon: 'lucide:smartphone',
+            badge: 'Auth',
+            external: Boolean(authOrigin)
+        },
+        {
+            id: 'providers',
+            title: 'Sign-in Providers',
+            description: 'Link or remove OAuth providers used for one-click sign-in.',
+            href: input.connectedAccountsHref ?? '/settings/connected-accounts',
+            actionLabel: 'Manage providers',
+            icon: 'lucide:link',
+            badge: 'Sign-in'
+        }
+    ];
+}
+export function summarizeOAuthProviders(providers) {
+    if (providers.length === 0)
+        return 'None linked';
+    return `${providers.length} connected`;
+}
+function trimTrailingSlash(value) {
+    return value.endsWith('/') ? value.slice(0, -1) : value;
+}
+function isExternalHref(href) {
+    return /^https?:\/\//.test(href);
+}

package/dist/svelte/settings/stores/settings.svelte.d.ts

@@ -0,0 +1,145 @@
+import { type RuntimeSource } from '../../runtime-log.ts';
+import { type UserSettings, type ChatSettings } from '../../../settings/schemas/common.ts';
+export declare const SETTINGS_CONTEXT_KEY: unique symbol;
+/**
+ * Keys of `UserSettings` whose value is a plain object (i.e. can be spread
+ * for partial merges). Primitive and array-valued keys (like `userType`
+ * and `useCases`) are intentionally excluded so `updateSetting` cannot be
+ * called with a category whose value is not an object.
+ */
+type ObjectCategoryKey = {
+    [K in keyof UserSettings]-?: NonNullable<UserSettings[K]> extends readonly unknown[] ? never : NonNullable<UserSettings[K]> extends object ? K : never;
+}[keyof UserSettings];
+export declare class SettingsStore {
+    private readonly runtime;
+    settings: {
+        ui: {
+            chat: {
+                inboxWidth: number;
+                conversationWidth: number;
+                messageAreaHeight: number;
+                inputAreaHeight: number;
+                showTimestamps: boolean;
+                messageDensity: "compact" | "comfortable" | "spacious";
+            };
+            theme: "system" | "light" | "dark";
+            sidebarCollapsed: boolean;
+            animations: boolean;
+        };
+        notifications: {
+            email: {
+                enabled: boolean;
+                mentions: boolean;
+                updates: boolean;
+                digest: "never" | "daily" | "weekly";
+            };
+            browser: {
+                enabled: boolean;
+                sound: boolean;
+            };
+            sources: {
+                creators: boolean;
+                projects: boolean;
+                friends: boolean;
+            };
+        };
+        privacy: {
+            profileVisibility: "team" | "public" | "private";
+            activityStatus: boolean;
+            readReceipts: boolean;
+            discoverable: boolean;
+            discoverabilityScope: "public" | "none" | "friends" | "authenticated";
+            publicProfile: boolean;
+            emailVisibility: "public" | "private" | "friends";
+            publicFigure: boolean;
+        };
+        useCases: ("team" | "creative" | "chat" | "knowledge" | "software" | "ai-ml")[];
+        profile?: {
+            name?: string | undefined;
+            email?: string | undefined;
+            bio?: string | undefined;
+            avatarUrl?: string | undefined;
+        } | undefined;
+        userType?: "simple" | "creative" | "power" | "developer" | undefined;
+        onboardingComplete?: boolean | undefined;
+        onboardingCompletedAt?: string | undefined;
+    } | undefined;
+    isLoading: boolean;
+    isSaving: boolean;
+    error: string | null;
+    private settingsSnapshot;
+    isDirty: boolean;
+    private createStableSnapshot;
+    /** The defaults the settings schema declares; if it cannot produce them, the store's own fallback (logged by class). */
+    private defaultSettings;
+    private saveDebounced;
+    /** `runtime` is the source the store logs through (the component's runtime store). */
+    constructor(runtime: RuntimeSource, initialSettings?: UserSettings | null);
+    /** Clear the debounce timer and save any pending edit now; call when the owning component is destroyed. */
+    dispose(): void;
+    private initializeSettings;
+    private createFallbackSettings;
+    load(): Promise<void>;
+    save(): Promise<void>;
+    loadFromServer(settings?: UserSettings): Promise<void>;
+    updateSettings(updates: Partial<UserSettings>): void;
+    resetSettings(): void;
+    updateSetting<K extends ObjectCategoryKey>(category: K, updates: Partial<UserSettings[K]>): void;
+    batchUpdate(updater: (settings: UserSettings) => void): void;
+    updateChatSettings(updates: Partial<ChatSettings>): void;
+    setChatInboxWidth(width: number): void;
+    setChatConversationWidth(width: number): void;
+    get ui(): {
+        chat: {
+            inboxWidth: number;
+            conversationWidth: number;
+            messageAreaHeight: number;
+            inputAreaHeight: number;
+            showTimestamps: boolean;
+            messageDensity: "compact" | "comfortable" | "spacious";
+        };
+        theme: "system" | "light" | "dark";
+        sidebarCollapsed: boolean;
+        animations: boolean;
+    } | undefined;
+    get notifications(): {
+        email: {
+            enabled: boolean;
+            mentions: boolean;
+            updates: boolean;
+            digest: "never" | "daily" | "weekly";
+        };
+        browser: {
+            enabled: boolean;
+            sound: boolean;
+        };
+        sources: {
+            creators: boolean;
+            projects: boolean;
+            friends: boolean;
+        };
+    } | undefined;
+    get privacy(): {
+        profileVisibility: "team" | "public" | "private";
+        activityStatus: boolean;
+        readReceipts: boolean;
+        discoverable: boolean;
+        discoverabilityScope: "public" | "none" | "friends" | "authenticated";
+        publicProfile: boolean;
+        emailVisibility: "public" | "private" | "friends";
+        publicFigure: boolean;
+    } | undefined;
+    get profile(): {
+        name?: string | undefined;
+        email?: string | undefined;
+        bio?: string | undefined;
+        avatarUrl?: string | undefined;
+    } | undefined;
+    get useCases(): ("team" | "creative" | "chat" | "knowledge" | "software" | "ai-ml")[] | undefined;
+    reset(): void;
+    resetCategory<K extends keyof UserSettings>(category: K): void;
+}
+export declare function setSettingsContext(settings: SettingsStore): SettingsStore;
+export declare function getSettingsContext(): SettingsStore;
+export {};
+//# sourceMappingURL=settings.svelte.d.ts.map

package/dist/svelte/settings/stores/settings.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings.svelte.d.ts","sourceRoot":"","sources":["../../../../src/svelte/settings/stores/settings.svelte.ts"],"names":[],"mappings":"AAKA,OAAO,EAAuC,KAAK,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC/F,OAAO,EAGN,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,MAAM,qCAAqC,CAAC;AAG7C,eAAO,MAAM,oBAAoB,eAAqB,CAAC;AAkDvD;;;;;GAKG;AACH,KAAK,iBAAiB,GAAG;KACvB,CAAC,IAAI,MAAM,YAAY,CAAC,CAAC,GAAG,WAAW,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,GACjF,KAAK,GACL,WAAW,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,SAAS,MAAM,GAC1C,CAAC,GACD,KAAK;CACT,CAAC,MAAM,YAAY,CAAC,CAAC;AAEtB,qBAAa,aAAa;IA+BxB,OAAO,CAAC,QAAQ,CAAC,OAAO;IA9BzB,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAA0B;IAClC,SAAS,UAAiB;IAC1B,QAAQ,UAAiB;IACzB,KAAK,gBAA+B;IAEpC,OAAO,CAAC,gBAAgB,CAAsB;IAC9C,OAAO,UAIL;IAEF,OAAO,CAAC,oBAAoB;IAI5B,wHAAwH;IACxH,OAAO,CAAC,eAAe;IASvB,OAAO,CAAC,aAAa,CAAqC;IAE1D,sFAAsF;gBAEpE,OAAO,EAAE,aAAa,EACvC,eAAe,CAAC,EAAE,YAAY,GAAG,IAAI;IAKtC,2GAA2G;IAC3G,OAAO;IAIP,OAAO,CAAC,kBAAkB;IAK1B,OAAO,CAAC,sBAAsB;IAkCxB,IAAI;IAqBJ,IAAI;IA2BJ,cAAc,CAAC,QAAQ,CAAC,EAAE,YAAY;IAW5C,cAAc,CAAC,OAAO,EAAE,OAAO,CAAC,YAAY,CAAC;IAO7C,aAAa;IAIb,aAAa,CAAC,CAAC,SAAS,iBAAiB,EAAE,QAAQ,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IAOzF,WAAW,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,YAAY,KAAK,IAAI;IAUrD,kBAAkB,CAAC,OAAO,EAAE,OAAO,CAAC,YAAY,CAAC;IAMjD,iBAAiB,CAAC,KAAK,EAAE,MAAM;IAM/B,wBAAwB,CAAC,KAAK,EAAE,MAAM;IAOtC,IAAI,EAAE;;;;;;;;;;;;kBAEL;IAED,IAAI,aAAa;;;;;;;;;;;;;;;;kBAEhB;IAED,IAAI,OAAO;;;;;;;;;kBAEV;IAED,IAAI,OAAO;;;;;kBAEV;IAED,IAAI,QAAQ,sFAEX;IAED,KAAK;IAML,aAAa,CAAC,CAAC,SAAS,MAAM,YAAY,EAAE,QAAQ,EAAE,CAAC;CAcvD;AAGD,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,aAAa,iBAIzD;AAED,wBAAgB,kBAAkB,IAAI,aAAa,CAMlD"}

package/dist/svelte/settings/stores/settings.svelte.js

@@ -0,0 +1,263 @@
+import * as z from 'zod/v4';
+import { getContext, onDestroy, setContext } from 'svelte';
+import { CapabilityError, settle, settleNow } from '@vibesdotdev/kernel';
+import { failureMessage } from '@vibesdotdev/account/api';
+import { jsonLikeSchema, stableJson } from "../../json.js";
+import { failureLabel, logOn, rethrowFailure } from "../../runtime-log.js";
+import { createDefaultSettings, normalizeUserSettings } from "../../../settings/schemas/common.js";
+export const SETTINGS_CONTEXT_KEY = Symbol('settings');
+/**
+ * Envelope schema for the `/api/account/settings` GET response.
+ *
+ * The inner `settings` payload is parsed as a loose object so the store does
+ * not duplicate `userSettingsSchema`'s field set here. Whatever the server
+ * returns under `settings` is then re-validated by `normalizeUserSettings`,
+ * which is the canonical normalizer for legacy / partial inputs.
+ */
+const settingsResponseEnvelopeSchema = z.object({
+    settings: z.object({}).loose().optional()
+});
+/** The refusal for a settings request the service answered with a failing status. */
+function settingsRequestFailed(action, status) {
+    return new CapabilityError(`The account settings could not be ${action === 'load' ? 'loaded' : 'saved'}.`, 'UNAVAILABLE', {
+        reason: 'account-settings-request-failed',
+        retryable: false,
+        details: { action, status }
+    });
+}
+function debounce(fn, ms) {
+    let timer;
+    return Object.assign(() => {
+        clearTimeout(timer);
+        timer = setTimeout(() => {
+            timer = undefined;
+            fn();
+        }, ms);
+    }, {
+        cancel: () => {
+            const pending = timer !== undefined;
+            clearTimeout(timer);
+            timer = undefined;
+            return pending;
+        }
+    });
+}
+export class SettingsStore {
+    runtime;
+    settings = $state();
+    isLoading = $state(false);
+    isSaving = $state(false);
+    error = $state(null);
+    settingsSnapshot = $state('');
+    isDirty = $derived(this.settings && this.settingsSnapshot
+        ? this.createStableSnapshot(this.settings) !== this.settingsSnapshot
+        : false);
+    createStableSnapshot(settings) {
+        return stableJson(jsonLikeSchema.parse(settings));
+    }
+    /** The defaults the settings schema declares; if it cannot produce them, the store's own fallback (logged by class). */
+    defaultSettings() {
+        const created = settleNow(() => createDefaultSettings());
+        if (created.ok)
+            return created.value;
+        void logOn(this.runtime, 'warn', 'account.settings-store', 'createDefaultSettings failed; using fallback settings', {
+            failure: failureLabel(created.cause)
+        });
+        return this.createFallbackSettings();
+    }
+    saveDebounced = debounce(() => this.save(), 1000);
+    /** `runtime` is the source the store logs through (the component's runtime store). */
+    constructor(runtime, initialSettings) {
+        this.runtime = runtime;
+        this.initializeSettings(initialSettings);
+    }
+    /** Clear the debounce timer and save any pending edit now; call when the owning component is destroyed. */
+    dispose() {
+        if (this.saveDebounced.cancel())
+            void this.save();
+    }
+    initializeSettings(initialSettings) {
+        this.settings = initialSettings ? initialSettings : this.defaultSettings();
+        this.settingsSnapshot = this.createStableSnapshot(this.settings);
+    }
+    createFallbackSettings() {
+        return {
+            ui: {
+                chat: {
+                    inboxWidth: 320,
+                    conversationWidth: 800,
+                    messageAreaHeight: 500,
+                    inputAreaHeight: 200,
+                    showTimestamps: true,
+                    messageDensity: 'comfortable'
+                },
+                theme: 'system',
+                sidebarCollapsed: false,
+                animations: true
+            },
+            notifications: {
+                email: { enabled: true, mentions: true, updates: false, digest: 'never' },
+                browser: { enabled: true, sound: false },
+                sources: { creators: true, projects: true, friends: true }
+            },
+            privacy: {
+                profileVisibility: 'team',
+                activityStatus: true,
+                readReceipts: true,
+                discoverable: true,
+                discoverabilityScope: 'authenticated',
+                publicProfile: true,
+                emailVisibility: 'private',
+                publicFigure: false
+            },
+            useCases: []
+        };
+    }
+    async load() {
+        this.isLoading = true;
+        this.error = null;
+        const loaded = await settle(async () => {
+            const response = await fetch('/api/account/settings');
+            if (!response.ok)
+                throw settingsRequestFailed('load', response.status);
+            const envelope = settingsResponseEnvelopeSchema.safeParse(await response.json());
+            const incoming = envelope.success ? envelope.data.settings : undefined;
+            this.settings = incoming ? normalizeUserSettings(incoming) : this.defaultSettings();
+            this.settingsSnapshot = this.createStableSnapshot(this.settings);
+        });
+        if (!loaded.ok) {
+            void logOn(this.runtime, 'warn', 'account.settings-store', 'Error loading settings', { failure: failureLabel(loaded.cause) });
+            this.error = failureMessage(loaded.cause, 'Failed to load settings');
+            this.settings = this.defaultSettings();
+            this.settingsSnapshot = this.createStableSnapshot(this.settings);
+        }
+        this.isLoading = false;
+    }
+    async save() {
+        if (!this.settings || this.isSaving)
+            return;
+        const currentSnapshot = this.createStableSnapshot(this.settings);
+        if (currentSnapshot === this.settingsSnapshot)
+            return;
+        this.isSaving = true;
+        this.error = null;
+        const saved = await settle(async () => {
+            const response = await fetch('/api/account/settings', {
+                method: 'PATCH',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ settings: this.settings })
+            });
+            if (!response.ok)
+                throw settingsRequestFailed('save', response.status);
+            this.settingsSnapshot = currentSnapshot;
+        });
+        this.isSaving = false;
+        if (!saved.ok) {
+            void logOn(this.runtime, 'warn', 'account.settings-store', 'Error saving settings', { failure: failureLabel(saved.cause) });
+            this.error = failureMessage(saved.cause, 'Failed to save settings');
+            rethrowFailure(saved.cause);
+        }
+    }
+    // Alias for load() to match test expectations
+    async loadFromServer(settings) {
+        if (settings) {
+            this.settings = settings;
+            this.settingsSnapshot = this.createStableSnapshot(settings);
+            this.isLoading = false;
+        }
+        else {
+            await this.load();
+        }
+    }
+    // Alias for batchUpdate to match test expectations
+    updateSettings(updates) {
+        this.batchUpdate((settings) => {
+            Object.assign(settings, updates);
+        });
+    }
+    // Alias for reset to match test expectations
+    resetSettings() {
+        this.reset();
+    }
+    updateSetting(category, updates) {
+        if (!this.settings)
+            return;
+        const current = this.settings[category];
+        this.settings[category] = { ...current, ...updates };
+        this.saveDebounced();
+    }
+    batchUpdate(updater) {
+        if (!this.settings)
+            return;
+        const originalSnapshot = this.createStableSnapshot(this.settings);
+        updater(this.settings);
+        const newSnapshot = this.createStableSnapshot(this.settings);
+        if (newSnapshot !== originalSnapshot) {
+            this.saveDebounced();
+        }
+    }
+    updateChatSettings(updates) {
+        if (!this.settings?.ui?.chat)
+            return;
+        this.settings.ui.chat = { ...this.settings.ui.chat, ...updates };
+        this.saveDebounced();
+    }
+    setChatInboxWidth(width) {
+        if (this.settings?.ui?.chat?.inboxWidth !== width) {
+            this.updateChatSettings({ inboxWidth: width });
+        }
+    }
+    setChatConversationWidth(width) {
+        if (this.settings?.ui?.chat?.conversationWidth !== width) {
+            this.updateChatSettings({ conversationWidth: width });
+        }
+    }
+    // UI convenience getters
+    get ui() {
+        return this.settings?.ui;
+    }
+    get notifications() {
+        return this.settings?.notifications;
+    }
+    get privacy() {
+        return this.settings?.privacy;
+    }
+    get profile() {
+        return this.settings?.profile;
+    }
+    get useCases() {
+        return this.settings?.useCases;
+    }
+    reset() {
+        this.settings = this.defaultSettings();
+        // Update snapshot to clear dirty state
+        this.settingsSnapshot = this.createStableSnapshot(this.settings);
+    }
+    resetCategory(category) {
+        const defaults = settleNow(() => createDefaultSettings());
+        if (!defaults.ok) {
+            // Skip reset if defaults fail; report why
+            void logOn(this.runtime, 'warn', 'account.settings-store', 'resetCategory: defaults unavailable; category left unchanged', {
+                category: String(category),
+                failure: failureLabel(defaults.cause)
+            });
+            return;
+        }
+        if (this.settings) {
+            this.settings[category] = defaults.value[category];
+        }
+    }
+}
+// Context helpers
+export function setSettingsContext(settings) {
+    // Tear the store's debounce timer down with the component that provides it.
+    onDestroy(() => settings.dispose());
+    return setContext(SETTINGS_CONTEXT_KEY, settings);
+}
+export function getSettingsContext() {
+    const context = getContext(SETTINGS_CONTEXT_KEY);
+    if (!context) {
+        throw new Error('Settings context not found. Ensure SettingsProvider is a parent component.');
+    }
+    return context;
+}