@astralyn/sash 0.1.0 → 0.1.2

package/dist/profile-service.js

@@ -1,667 +1,330 @@
 import fs from "node:fs";
-import { isDeepStrictEqual } from "node:util";
-import YAML from "yaml";
-import { commitManagedStateTransaction, defaultManagedStateFileOperations, } from "./managed-state-transaction.js";
-import { buildDefaultConfig, fetchSubscriptionProfile, isValidMihomoConfig, renderConfig, } from "./mihomo-config.js";
-import { allocateProfileId, findProfileByUrl, getActiveProfile, loadProfiles, MAX_PROFILE_INTERVAL_HOURS, profileDueForUpdate, profileFilePath, profileNameFromUrl, readProfileDigest, readProfileSource, } from "./profiles.js";
-import { sameSettings } from "./settings.js";
+import { StateConflictError } from "./app-state.js";
+import { atomicWriteFileSync, durableRemoveFileSync } from "./fs-atomic.js";
+import { fetchSubscriptionProfile } from "./mihomo-config.js";
+import { allocateProfileId, getActiveProfile, MAX_PROFILE_INTERVAL_HOURS, parseProfileText, profileDueForUpdate, profileFilePath, profileNameFromUrl, readProfileSource, } from "./profiles.js";
 export class ProfileInputError extends Error {
 }
-export class GeneratedConfigError extends Error {
-}
 export class ProfileNotFoundError extends Error {
 }
-export class ProfileConflictError extends Error {
-}
-async function mapConcurrent(items, limit, worker) {
-    const results = new Array(items.length);
-    let cursor = 0;
-    const runners = Array.from({ length: Math.min(limit, items.length) }, async () => {
-        for (;;) {
-            const index = cursor++;
-            const item = items[index];
-            if (item === undefined)
-                return;
-            results[index] = await worker(item);
-        }
-    });
-    await Promise.all(runners);
-    return results;
-}
-function sameProfileState(before, current) {
-    return isDeepStrictEqual(before, current);
-}
-function opaqueToken() {
-    return Object.freeze({});
-}
-function replaceProfileMeta(index, replacement) {
-    return {
-        ...index,
-        profiles: index.profiles.map((profile) => profile.id === replacement.id ? replacement : profile),
-    };
-}
-function currentProfile(index, snapshot, activeId) {
-    const profile = index.profiles.find((item) => item.id === snapshot.id);
-    if (!profile || !isDeepStrictEqual(profile, snapshot) || index.activeId !== activeId) {
-        throw new ProfileConflictError(`profile changed or was removed during update: ${snapshot.id}`);
+export { StateConflictError as ProfileConflictError } from "./app-state.js";
+function profileInput(content) {
+    try {
+        return parseProfileText(content);
+    }
+    catch (error) {
+        throw new ProfileInputError(error instanceof Error ? error.message : String(error));
     }
-    return profile;
-}
-function validFetchedInterval(value, fallback) {
-    return value !== undefined &&
-        Number.isSafeInteger(value) &&
-        value > 0 &&
-        value <= MAX_PROFILE_INTERVAL_HOURS
-        ? value
-        : fallback;
 }
-function withFetchedContent(profile, fetched) {
-    return {
-        ...profile,
-        updatedAt: new Date().toISOString(),
-        ...(fetched.subInfo ? { subInfo: fetched.subInfo } : {}),
-        ...(fetched.homePage ? { homePage: fetched.homePage } : {}),
-        intervalHours: validFetchedInterval(fetched.intervalHours, profile.intervalHours),
-        lastError: undefined,
-    };
+function validName(name) {
+    const result = name.trim();
+    if (!result || result.length > 120)
+        throw new ProfileInputError("Profile name must contain 1 to 120 characters");
+    return result;
 }
 export class ProfileService {
-    layout;
-    getSettings;
-    fetchProfileFn;
-    validateConfig;
-    reloadConfig;
-    commitBoundary;
-    onChange;
-    files;
-    fetches = new Map();
-    preparedActiveConfigs = new WeakMap();
-    preparedActiveReloads = new WeakMap();
-    commitTail = Promise.resolve();
-    constructor(opts) {
-        this.layout = opts.layout;
-        this.getSettings = opts.settings;
-        this.fetchProfileFn = opts.fetchProfile ?? fetchSubscriptionProfile;
-        this.validateConfig = opts.validateConfig;
-        this.reloadConfig = opts.reloadConfig;
-        this.commitBoundary = opts.commit;
-        this.onChange = opts.onChange;
-        this.files = opts.fileOperations ?? defaultManagedStateFileOperations;
+    options;
+    downloads = new Set();
+    updatingDue = false;
+    downloadGeneration = 0;
+    constructor(options) {
+        this.options = options;
     }
     list() {
-        return loadProfiles(this.layout);
+        return this.options.state.snapshot().profiles;
     }
     active() {
         return getActiveProfile(this.list());
     }
-    commit(purpose, action) {
-        if (this.commitBoundary)
-            return this.commitBoundary(purpose, action);
-        const next = this.commitTail.then(action, action);
-        this.commitTail = next.then(() => undefined, () => undefined);
-        return next;
-    }
-    fetch(url) {
-        const existing = this.fetches.get(url);
-        if (existing)
-            return existing;
-        const pending = this.fetchProfileFn(url).finally(() => {
-            if (this.fetches.get(url) === pending)
-                this.fetches.delete(url);
-        });
-        this.fetches.set(url, pending);
-        return pending;
-    }
-    settingsSnapshot() {
-        return { ...this.getSettings() };
+    cancelDownloads() {
+        this.downloadGeneration += 1;
+        for (const download of this.downloads)
+            download.abort(new StateConflictError("Profile download cancelled"));
     }
-    assertSettingsUnchanged(snapshot) {
-        if (!sameSettings(this.getSettings(), snapshot)) {
-            throw new ProfileConflictError("Settings changed while preparing profile configuration");
-        }
-    }
-    assertProfileContentCurrent(id, digest, message = "Profile content changed while preparing configuration") {
-        if (readProfileDigest(this.layout, id) !== digest) {
-            throw new ProfileConflictError(`${message}: ${id}`);
+    async fetch(url) {
+        const controller = new AbortController();
+        this.downloads.add(controller);
+        try {
+            const fetched = await (this.options.fetchProfile ?? fetchSubscriptionProfile)(url, controller.signal);
+            controller.signal.throwIfAborted();
+            profileInput(fetched.yamlText);
+            return fetched;
         }
-    }
-    updateSnapshot(profile, activeId, contentDigest = readProfileDigest(this.layout, profile.id)) {
-        return { profile, activeId, contentDigest };
-    }
-    recheckProfileSnapshot(index, snapshot, contentMessage = "Profile content changed while preparing configuration") {
-        const profile = currentProfile(index, snapshot.profile, snapshot.activeId);
-        this.assertProfileContentCurrent(profile.id, snapshot.contentDigest, contentMessage);
-        return profile;
-    }
-    async resolveActiveSource(index) {
-        const active = getActiveProfile(index);
-        if (!active) {
-            return {
-                activeId: index.activeId,
-                active: null,
-                sourceDigest: null,
-                doc: null,
-            };
+        catch (error) {
+            controller.signal.throwIfAborted();
+            throw error;
         }
-        const stored = readProfileSource(this.layout, active.id);
-        const fetched = stored === undefined && active.url ? await this.fetch(active.url) : undefined;
-        if (stored === undefined && !fetched) {
-            throw new ProfileInputError(`Local profile file is missing: ${active.id}`);
+        finally {
+            this.downloads.delete(controller);
         }
-        return {
-            activeId: index.activeId,
-            active,
-            sourceDigest: stored?.digest ?? null,
-            doc: fetched?.doc ?? stored?.doc ?? null,
-            ...(fetched ? { fetched } : {}),
-        };
     }
-    takePreparedActiveConfig(prepared) {
-        const state = this.preparedActiveConfigs.get(prepared);
-        if (!state) {
-            throw new TypeError("Prepared active configuration is invalid or already consumed");
-        }
-        this.preparedActiveConfigs.delete(prepared);
-        return state;
+    requireProfile(index, id) {
+        const profile = index.profiles.find((item) => item.id === id);
+        if (!profile)
+            throw new ProfileNotFoundError(`Profile not found: ${id}`);
+        return profile;
     }
-    takePreparedActiveReload(prepared) {
-        const state = this.preparedActiveReloads.get(prepared);
-        if (!state) {
-            throw new TypeError("Prepared active reload is invalid or already consumed");
+    recheck(index, before) {
+        const current = this.requireProfile(index, before.id);
+        if (current.revision !== before.revision || current.url !== before.url) {
+            throw new StateConflictError("Profile changed while downloading or editing; refresh and retry");
         }
-        this.preparedActiveReloads.delete(prepared);
-        return state;
-    }
-    preparedActiveReload(state) {
-        const prepared = opaqueToken();
-        this.preparedActiveReloads.set(prepared, state);
-        return prepared;
+        return current;
     }
-    async prepareActiveConfig(settings, rollbackSettings = this.settingsSnapshot()) {
-        const rollbackSnapshot = { ...rollbackSettings };
-        const source = await this.resolveActiveSource(this.list());
-        const generated = await this.prepare(source.doc, settings);
-        let rollbackConfig;
-        if (sameSettings(settings, rollbackSnapshot)) {
-            rollbackConfig = { generated };
-        }
-        else {
+    publishSource(index, profile, text, select) {
+        const state = this.options.state.snapshot();
+        const previous = index.profiles.find((item) => item.id === profile.id);
+        let unchanged = false;
+        if (previous) {
             try {
-                rollbackConfig = { generated: await this.prepare(source.doc, rollbackSnapshot) };
+                unchanged = readProfileSource(this.options.layout, previous).yamlText === text;
             }
-            catch (error) {
-                rollbackConfig = { error };
+            catch {
             }
         }
-        const prepared = opaqueToken();
-        this.preparedActiveConfigs.set(prepared, {
-            generated,
-            rollbackConfig,
-            rollbackSettings: rollbackSnapshot,
-            activeId: source.activeId,
-            sourceDigest: source.sourceDigest,
-            ...(source.active ? { active: { id: source.active.id, url: source.active.url } } : {}),
-            ...(source.fetched ? { fetched: source.fetched } : {}),
+        let revision = profile.revision;
+        if (unchanged && previous)
+            revision = previous.revision;
+        else
+            while (fs.existsSync(profileFilePath(this.options.layout, profile.id, revision)))
+                revision += 1;
+        const next = { ...profile, revision };
+        const file = profileFilePath(this.options.layout, next.id, next.revision);
+        if (!unchanged)
+            atomicWriteFileSync(file, text);
+        const profiles = previous
+            ? index.profiles.map((item) => (item.id === next.id ? next : item))
+            : [...index.profiles, next];
+        this.options.state.commit({
+            ...state,
+            profiles: { activeId: select ? next.id : index.activeId, profiles },
         });
-        return prepared;
-    }
-    async withPreparedActivePublication(prepared, callback) {
-        const state = this.takePreparedActiveConfig(prepared);
-        this.assertSettingsUnchanged(state.rollbackSettings);
-        const index = this.list();
-        if (index.activeId !== state.activeId) {
-            throw new ProfileConflictError("Active profile changed while preparing configuration");
-        }
-        let active = null;
-        if (state.active) {
-            active = getActiveProfile(index);
-            if (!active || active.id !== state.active.id || active.url !== state.active.url) {
-                throw new ProfileConflictError("Active profile changed while preparing configuration");
+        if (previous && previous.revision !== next.revision) {
+            try {
+                durableRemoveFileSync(profileFilePath(this.options.layout, previous.id, previous.revision));
             }
-            this.assertProfileContentCurrent(active.id, state.sourceDigest);
-        }
-        const rollback = this.preparedActiveReload({
-            ...state.rollbackConfig,
-            settings: state.rollbackSettings,
-            activeId: index.activeId,
-            sourceDigest: state.sourceDigest,
-            ...(active ? { active } : {}),
-        });
-        const publication = active && state.fetched
-            ? {
-                config: state.generated,
-                rollback,
-                index: replaceProfileMeta(index, withFetchedContent(active, state.fetched)),
-                profile: { id: active.id, yamlText: state.fetched.yamlText },
+            catch {
             }
-            : { config: state.generated, rollback };
-        const result = await callback(publication);
-        if (publication.profile)
-            this.notifyChange();
-        return result;
-    }
-    async prepareActiveReload() {
-        const source = await this.resolveActiveSource(this.list());
-        const settings = this.settingsSnapshot();
-        return this.preparedActiveReload({
-            generated: await this.prepare(source.doc, settings),
-            settings,
-            activeId: source.activeId,
-            sourceDigest: source.sourceDigest,
-            ...(source.active ? { active: source.active } : {}),
-            ...(source.fetched ? { fetched: source.fetched } : {}),
-        });
-    }
-    async withPreparedActiveReloadPublication(prepared, callback) {
-        const state = this.takePreparedActiveReload(prepared);
-        if ("error" in state)
-            throw state.error;
-        this.assertSettingsUnchanged(state.settings);
-        const index = this.list();
-        if (index.activeId !== state.activeId) {
-            throw new ProfileConflictError("Active profile changed while preparing configuration");
-        }
-        let publication;
-        if (!state.active) {
-            publication = { config: state.generated, index };
-        }
-        else {
-            const profile = this.recheckProfileSnapshot(index, this.updateSnapshot(state.active, state.activeId, state.sourceDigest));
-            const updated = state.fetched ? withFetchedContent(profile, state.fetched) : profile;
-            publication = {
-                config: state.generated,
-                index: replaceProfileMeta(index, updated),
-                ...(state.fetched ? { profile: { id: profile.id, yamlText: state.fetched.yamlText } } : {}),
-            };
         }
-        const result = await callback(publication);
-        this.notifyChange();
-        return result;
-    }
-    async commitPreparedActiveReload(prepared, options = {}) {
-        const reloadRuntime = options.reloadRuntime ?? true;
-        const boundary = options.boundary ?? "acquire";
-        if (boundary !== "acquire" && boundary !== "already-held") {
-            throw new TypeError(`Unknown profile commit boundary: ${String(boundary)}`);
-        }
-        const action = () => this.withPreparedActiveReloadPublication(prepared, async (publication) => {
-            await this.publishTransaction(publication.index, {
-                ...(publication.profile ? { profile: publication.profile } : {}),
-                config: publication.config,
-                reloadRuntime,
-            });
-            return publication.config;
-        });
-        return boundary === "acquire" ? this.commit("reload active profile", action) : action();
-    }
-    async reloadActive(options = {}) {
-        return this.commitPreparedActiveReload(await this.prepareActiveReload(), options);
-    }
-    notifyChange() {
-        try {
-            this.onChange?.();
-        }
-        catch {
-        }
-    }
-    async prepare(doc, settings) {
-        const generated = renderConfig(doc ?? buildDefaultConfig(), settings, doc ? "subscription" : "default");
-        try {
-            await this.validateConfig?.(generated);
-        }
-        catch (err) {
-            throw new GeneratedConfigError(err.message);
-        }
-        return generated;
-    }
-    async publishTransaction(index, opts = {}) {
-        await commitManagedStateTransaction(this.layout, { index, ...opts }, this.reloadConfig, this.files);
+        return next;
     }
-    async publish(index, opts = {}) {
-        await this.publishTransaction(index, opts);
-        this.notifyChange();
+    fetchedMeta(profile, fetched) {
+        const interval = fetched.intervalHours;
+        return {
+            ...profile,
+            revision: profile.revision + 1,
+            updatedAt: new Date().toISOString(),
+            ...(fetched.subInfo ? { subInfo: fetched.subInfo } : {}),
+            ...(fetched.homePage ? { homePage: fetched.homePage } : {}),
+            intervalHours: interval !== undefined &&
+                Number.isSafeInteger(interval) &&
+                interval > 0 &&
+                interval <= MAX_PROFILE_INTERVAL_HOURS
+                ? interval
+                : profile.intervalHours,
+            lastError: undefined,
+        };
     }
     async addRemote(url, opts = {}) {
-        const normalizedUrl = url.trim();
-        if (!normalizedUrl)
+        const normalized = url.trim();
+        if (!normalized)
             throw new ProfileInputError("Missing required profile URL");
-        const before = this.list();
-        const settings = this.settingsSnapshot();
-        const known = findProfileByUrl(before, normalizedUrl);
-        const knownDigest = known ? readProfileDigest(this.layout, known.id) : null;
-        const fetched = await this.fetch(normalizedUrl);
-        const prepared = await this.prepare(fetched.doc, settings);
-        return this.commit("add profile", async () => {
-            this.assertSettingsUnchanged(settings);
-            const current = this.list();
-            let profile;
-            let profileChange;
-            if (known) {
-                const existing = currentProfile(current, known, before.activeId);
-                this.assertProfileContentCurrent(existing.id, knownDigest, "Profile changed while updating");
-                profile = withFetchedContent(existing, fetched);
-                profileChange = { id: profile.id, yamlText: fetched.yamlText };
-            }
-            else {
-                if (!sameProfileState(before, current) || findProfileByUrl(current, normalizedUrl)) {
-                    throw new ProfileConflictError("Profiles changed while adding a remote profile");
-                }
-                const id = allocateProfileId(current, this.layout);
-                const now = new Date().toISOString();
-                profile = {
-                    id,
-                    name: opts.name?.trim() || fetched.name || profileNameFromUrl(normalizedUrl),
-                    url: normalizedUrl,
-                    intervalHours: validFetchedInterval(fetched.intervalHours, 24),
-                    createdAt: now,
-                    updatedAt: now,
-                    ...(fetched.subInfo ? { subInfo: fetched.subInfo } : {}),
-                    ...(fetched.homePage ? { homePage: fetched.homePage } : {}),
-                };
-                profileChange = { id, yamlText: fetched.yamlText };
-            }
-            const shouldActivate = opts.activate === true || current.activeId === null;
-            const index = {
-                activeId: shouldActivate ? profile.id : current.activeId,
-                profiles: known
-                    ? current.profiles.map((item) => (item.id === profile.id ? profile : item))
-                    : [...current.profiles, profile],
-            };
-            await this.publish(index, {
-                profile: profileChange,
-                ...(shouldActivate ? { config: prepared } : {}),
-            });
-            return {
-                profile,
-                activated: shouldActivate,
-                ...(shouldActivate ? { proxyCount: prepared.proxyCount } : {}),
+        const known = this.list().profiles.find((profile) => profile.url === normalized);
+        const fetched = await this.fetch(normalized);
+        return this.options.commit("save remote profile", () => {
+            const index = this.list();
+            const now = new Date().toISOString();
+            const existing = known ? this.recheck(index, known) : undefined;
+            if (!known && index.profiles.some((profile) => profile.url === normalized))
+                throw new StateConflictError("Profile was added during download");
+            const base = existing ?? {
+                id: allocateProfileId(index, this.options.layout),
+                revision: 0,
+                name: validName(opts.name ?? fetched.name?.slice(0, 120) ?? profileNameFromUrl(normalized)),
+                url: normalized,
+                intervalHours: 24,
+                createdAt: now,
+                updatedAt: now,
             };
+            const activated = opts.activate === true || index.activeId === null;
+            const profile = this.publishSource(index, this.fetchedMeta(base, fetched), fetched.yamlText, activated);
+            return { profile, activated };
         });
     }
     async importLocal(name, content) {
-        if (!content.trim())
-            throw new ProfileInputError("Missing required profile content");
-        let doc;
-        try {
-            doc = YAML.parse(content);
-        }
-        catch (err) {
-            throw new ProfileInputError(`Content is not valid YAML: ${err.message}`);
-        }
-        if (!isValidMihomoConfig(doc)) {
-            throw new ProfileInputError("Content is not a valid core configuration (missing proxies/rules)");
-        }
-        const settings = this.settingsSnapshot();
-        const prepared = await this.prepare(doc, settings);
-        const before = this.list();
-        return this.commit("import profile", async () => {
-            this.assertSettingsUnchanged(settings);
-            const current = this.list();
-            if (!sameProfileState(before, current)) {
-                throw new ProfileConflictError("Profiles changed while importing a local profile");
-            }
-            const id = allocateProfileId(current, this.layout);
+        profileInput(content);
+        const displayName = validName(name);
+        return this.options.commit("import profile", () => {
+            const index = this.list();
             const now = new Date().toISOString();
-            const profile = {
-                id,
-                name: name.trim() || "imported",
+            const activated = index.activeId === null;
+            const profile = this.publishSource(index, {
+                id: allocateProfileId(index, this.options.layout),
+                revision: 1,
+                name: displayName,
                 url: "",
                 intervalHours: 0,
                 createdAt: now,
                 updatedAt: now,
-            };
-            const activated = current.activeId === null;
-            await this.publish({ activeId: activated ? id : current.activeId, profiles: [...current.profiles, profile] }, {
-                profile: { id, yamlText: content },
-                ...(activated ? { config: prepared } : {}),
-            });
-            return { profile, activated, ...(activated ? { proxyCount: prepared.proxyCount } : {}) };
+            }, content, activated);
+            return { profile, activated };
         });
     }
     readContent(id) {
-        const profile = this.list().profiles.find((item) => item.id === id);
-        if (!profile)
-            throw new ProfileNotFoundError(`profile not found: ${id}`);
-        let content;
-        try {
-            content = fs.readFileSync(profileFilePath(this.layout, profile.id), "utf8");
-        }
-        catch {
-            throw new ProfileNotFoundError(`profile file is missing: ${profile.id}`);
-        }
-        return { name: profile.name, content };
+        const profile = this.requireProfile(this.list(), id);
+        return {
+            name: profile.name,
+            content: readProfileSource(this.options.layout, profile).yamlText,
+            revision: profile.revision,
+        };
     }
-    async writeContent(id, content) {
-        if (!content.trim())
-            throw new ProfileInputError("Missing required profile content");
-        let doc;
-        try {
-            doc = YAML.parse(content);
-        }
-        catch (err) {
-            throw new ProfileInputError(`Content is not valid YAML: ${err.message}`);
-        }
-        if (!isValidMihomoConfig(doc)) {
-            throw new ProfileInputError("Content is not a valid core configuration (missing proxies/rules)");
-        }
-        const before = this.list();
-        const target = before.profiles.find((item) => item.id === id);
-        if (!target)
-            throw new ProfileNotFoundError(`profile not found: ${id}`);
-        const snapshot = this.updateSnapshot(target, before.activeId);
-        const settings = this.settingsSnapshot();
-        const prepared = await this.prepare(doc, settings);
-        return this.commit("edit profile", async () => {
-            this.assertSettingsUnchanged(settings);
+    async writeContent(id, content, revision) {
+        profileInput(content);
+        return this.options.commit("save profile edit", () => {
             const index = this.list();
-            const profile = this.recheckProfileSnapshot(index, snapshot, "Profile changed while editing");
-            const updated = {
-                ...profile,
+            const before = this.requireProfile(index, id);
+            if (before.revision !== revision)
+                throw new StateConflictError("Profile changed since the editor opened; reload before saving");
+            const profile = this.publishSource(index, {
+                ...before,
+                revision: before.revision + 1,
                 updatedAt: new Date().toISOString(),
                 lastError: undefined,
-            };
-            const active = index.activeId === profile.id;
-            await this.publish({
-                ...index,
-                profiles: index.profiles.map((item) => (item.id === profile.id ? updated : item)),
-            }, {
-                profile: { id: profile.id, yamlText: content },
-                ...(active ? { config: prepared } : {}),
-            });
-            return { profile: updated, ...(active ? { proxyCount: prepared.proxyCount } : {}) };
+            }, content, false);
+            return { profile };
         });
     }
     async activate(id) {
-        const before = this.list();
-        const settings = this.settingsSnapshot();
-        if (id === null) {
-            const prepared = await this.prepare(null, settings);
-            return this.commit("deselect profile", async () => {
-                this.assertSettingsUnchanged(settings);
-                const current = this.list();
-                if (current.activeId !== before.activeId) {
-                    throw new ProfileConflictError("Active profile changed while preparing configuration");
-                }
-                await this.publish({ ...current, activeId: null }, { config: prepared });
-                return { activeId: null, proxyCount: prepared.proxyCount };
-            });
-        }
-        const initial = before.profiles.find((profile) => profile.id === id);
-        if (!initial)
-            throw new ProfileNotFoundError(`profile not found: ${id}`);
-        const stored = readProfileSource(this.layout, id);
-        const fetched = stored === undefined && initial.url ? await this.fetch(initial.url) : undefined;
-        if (stored === undefined && !fetched) {
-            throw new ProfileInputError(`Local profile file is missing: ${id}`);
-        }
-        const sourceDigest = stored?.digest ?? null;
-        const prepared = await this.prepare(fetched?.doc ?? stored?.doc ?? null, settings);
-        return this.commit("activate profile", async () => {
-            this.assertSettingsUnchanged(settings);
-            const current = this.list();
-            const profile = currentProfile(current, initial, before.activeId);
-            this.assertProfileContentCurrent(profile.id, sourceDigest);
-            const updated = fetched ? withFetchedContent(profile, fetched) : profile;
-            await this.publish({
-                activeId: id,
-                profiles: current.profiles.map((item) => (item.id === id ? updated : item)),
-            }, {
-                ...(fetched ? { profile: { id, yamlText: fetched.yamlText } } : {}),
-                config: prepared,
-            });
-            return { activeId: id, proxyCount: prepared.proxyCount };
-        });
-    }
-    async commitFetched(snapshot, fetched) {
-        const settings = this.settingsSnapshot();
-        const prepared = await this.prepare(fetched.doc, settings);
-        return this.commit("update profile", async () => {
-            this.assertSettingsUnchanged(settings);
-            const index = this.list();
-            const current = currentProfile(index, snapshot.profile, snapshot.activeId);
-            this.assertProfileContentCurrent(current.id, snapshot.contentDigest, "Profile changed while updating");
-            const profile = withFetchedContent(current, fetched);
-            const active = index.activeId === current.id;
-            await this.publish({
-                ...index,
-                profiles: index.profiles.map((item) => (item.id === current.id ? profile : item)),
-            }, {
-                profile: { id: current.id, yamlText: fetched.yamlText },
-                ...(active ? { config: prepared } : {}),
-            });
-            return { profile, ...(active ? { proxyCount: prepared.proxyCount } : {}) };
-        });
-    }
-    async recordError(snapshot, error) {
-        await this.commit("record profile update error", async () => {
-            const index = this.list();
-            let current;
-            try {
-                current = currentProfile(index, snapshot.profile, snapshot.activeId);
-                this.assertProfileContentCurrent(current.id, snapshot.contentDigest, "Profile changed while recording an update error");
-            }
-            catch (err) {
-                if (err instanceof ProfileConflictError)
-                    return;
-                throw err;
-            }
-            const profile = { ...current, lastError: error.slice(0, 300) };
-            await this.publish({
-                ...index,
-                profiles: index.profiles.map((item) => (item.id === current.id ? profile : item)),
-            });
+        return this.options.commit("select profile", () => {
+            const state = this.options.state.snapshot();
+            const profile = id === null ? null : this.requireProfile(state.profiles, id);
+            const doc = profile ? readProfileSource(this.options.layout, profile).doc : null;
+            if (state.profiles.activeId !== id)
+                this.options.state.commit({ ...state, profiles: { ...state.profiles, activeId: id } });
+            return { activeId: id, proxyCount: Array.isArray(doc?.proxies) ? doc.proxies.length : 0 };
         });
     }
     async update(id) {
-        const index = this.list();
-        const profile = index.profiles.find((item) => item.id === id);
-        if (!profile)
-            throw new ProfileNotFoundError(`profile not found: ${id}`);
-        if (!profile.url)
+        const before = this.requireProfile(this.list(), id);
+        if (!before.url)
             throw new ProfileInputError("Local profile has no URL to update from");
-        const snapshot = this.updateSnapshot(profile, index.activeId);
         try {
-            return await this.commitFetched(snapshot, await this.fetch(profile.url));
+            const fetched = await this.fetch(before.url);
+            return await this.options.commit("update profile", () => {
+                const index = this.list();
+                const current = this.recheck(index, before);
+                return {
+                    profile: this.publishSource(index, this.fetchedMeta(current, fetched), fetched.yamlText, false),
+                };
+            });
         }
-        catch (err) {
-            await this.recordError(snapshot, err.message);
-            throw err;
+        catch (error) {
+            await this.options
+                .commit("record profile error", () => {
+                const state = this.options.state.snapshot();
+                const current = state.profiles.profiles.find((profile) => profile.id === id);
+                if (!current || current.revision !== before.revision || current.url !== before.url)
+                    return;
+                const message = (error instanceof Error ? error.message : String(error)).slice(0, 300);
+                this.options.state.commit({
+                    ...state,
+                    profiles: {
+                        ...state.profiles,
+                        profiles: state.profiles.profiles.map((profile) => profile.id === id ? { ...profile, lastError: message } : profile),
+                    },
+                });
+            })
+                .catch(() => undefined);
+            throw error;
         }
     }
     async updateProfiles(profiles) {
-        const fetched = await mapConcurrent(profiles, 4, async (snapshot) => {
-            try {
-                return { snapshot, fetched: await this.fetch(snapshot.profile.url) };
-            }
-            catch (err) {
-                return { snapshot, error: err.message };
-            }
-        });
-        let updated = 0;
-        let proxyCount;
-        const failed = [];
-        for (const result of fetched) {
-            const { profile } = result.snapshot;
-            if (!("fetched" in result)) {
-                await this.recordError(result.snapshot, result.error);
-                failed.push({ id: profile.id, name: profile.name, error: result.error });
-                continue;
-            }
-            try {
-                const committed = await this.commitFetched(result.snapshot, result.fetched);
-                updated += 1;
-                if (committed.proxyCount !== undefined)
-                    proxyCount = committed.proxyCount;
-            }
-            catch (err) {
-                const message = err.message;
-                await this.recordError(result.snapshot, message);
-                failed.push({ id: profile.id, name: profile.name, error: message });
+        const result = { updated: 0, failed: [] };
+        const generation = this.downloadGeneration;
+        for (let start = 0; start < profiles.length; start += 4) {
+            if (generation !== this.downloadGeneration) {
+                result.failed.push(...profiles.slice(start).map((profile) => ({
+                    id: profile.id,
+                    name: profile.name,
+                    error: "Profile update cancelled",
+                })));
+                break;
             }
+            await Promise.all(profiles.slice(start, start + 4).map(async (profile) => {
+                try {
+                    await this.update(profile.id);
+                    result.updated += 1;
+                }
+                catch (error) {
+                    result.failed.push({
+                        id: profile.id,
+                        name: profile.name,
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            }));
         }
-        return { updated, failed, ...(proxyCount !== undefined ? { proxyCount } : {}) };
+        return result;
     }
-    async updateAll() {
-        const index = this.list();
-        return this.updateProfiles(index.profiles
-            .filter((profile) => profile.url !== "")
-            .map((profile) => this.updateSnapshot(profile, index.activeId)));
+    updateAll() {
+        return this.updateProfiles(this.list().profiles.filter((profile) => profile.url));
     }
     async updateDue(nowMs = Date.now()) {
-        const index = this.list();
-        return this.updateProfiles(index.profiles
-            .filter((profile) => {
-            let exists = false;
+        if (this.updatingDue)
+            return { updated: 0, failed: [] };
+        this.updatingDue = true;
+        try {
+            return await this.updateProfiles(this.list().profiles.filter((profile) => profileDueForUpdate(profile, nowMs)));
+        }
+        finally {
+            this.updatingDue = false;
+        }
+    }
+    async remove(id) {
+        return this.options.commit("remove profile", () => {
+            const state = this.options.state.snapshot();
+            const profile = this.requireProfile(state.profiles, id);
+            const wasActive = state.profiles.activeId === id;
+            this.options.state.commit({
+                ...state,
+                profiles: {
+                    activeId: wasActive ? null : state.profiles.activeId,
+                    profiles: state.profiles.profiles.filter((item) => item.id !== id),
+                },
+            });
             try {
-                exists = fs.existsSync(profileFilePath(this.layout, profile.id));
+                durableRemoveFileSync(profileFilePath(this.options.layout, profile.id, profile.revision));
             }
             catch {
             }
-            return profileDueForUpdate(profile, exists, nowMs);
-        })
-            .map((profile) => this.updateSnapshot(profile, index.activeId)));
+            return { wasActive };
+        });
     }
-    async remove(id) {
-        const before = this.list();
-        const initial = before.profiles.find((profile) => profile.id === id);
-        if (!initial)
-            throw new ProfileNotFoundError(`profile not found: ${id}`);
-        const sourceDigest = readProfileDigest(this.layout, id);
-        const settings = this.settingsSnapshot();
-        const prepared = before.activeId === id ? await this.prepare(null, settings) : undefined;
-        return this.commit("remove profile", async () => {
-            this.assertSettingsUnchanged(settings);
-            const index = this.list();
-            const profile = currentProfile(index, initial, before.activeId);
-            this.assertProfileContentCurrent(profile.id, sourceDigest, "Profile changed while deleting");
-            const wasActive = index.activeId === profile.id;
-            await this.publish({
-                activeId: wasActive ? null : index.activeId,
-                profiles: index.profiles.filter((item) => item.id !== id),
-            }, {
-                profile: { id, yamlText: null },
-                ...(prepared ? { config: prepared } : {}),
-            });
-            return { wasActive, ...(prepared ? { proxyCount: prepared.proxyCount } : {}) };
+    async reorder(ids) {
+        return this.options.commit("reorder profiles", () => {
+            const state = this.options.state.snapshot();
+            if (ids.length !== state.profiles.profiles.length || new Set(ids).size !== ids.length)
+                throw new ProfileInputError("Profile order must contain every profile exactly once");
+            const profiles = ids.map((id) => this.requireProfile(state.profiles, id));
+            if (profiles.every((profile, i) => profile.id === state.profiles.profiles[i]?.id))
+                return state.profiles;
+            return this.options.state.commit({ ...state, profiles: { ...state.profiles, profiles } })
+                .profiles;
         });
     }
     async rename(id, name) {
-        const trimmed = name.trim();
-        if (!trimmed)
-            throw new ProfileInputError("Missing required profile name");
-        if (trimmed.length > 120)
-            throw new ProfileInputError("Profile name is too long");
-        return this.commit("rename profile", async () => {
-            const index = this.list();
-            const profile = index.profiles.find((item) => item.id === id);
-            if (!profile)
-                throw new ProfileNotFoundError(`profile not found: ${id}`);
-            const updated = { ...profile, name: trimmed };
-            await this.publish({
-                ...index,
-                profiles: index.profiles.map((item) => (item.id === id ? updated : item)),
+        const displayName = validName(name);
+        return this.options.commit("rename profile", () => {
+            const state = this.options.state.snapshot();
+            const profile = { ...this.requireProfile(state.profiles, id), name: displayName };
+            this.options.state.commit({
+                ...state,
+                profiles: {
+                    ...state.profiles,
+                    profiles: state.profiles.profiles.map((item) => (item.id === id ? profile : item)),
+                },
             });
-            return { profile: updated };
+            return { profile };
         });
     }
 }