@astralyn/sash 0.1.0

package/dist/profile-service.js

@@ -0,0 +1,667 @@
+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";
+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}`);
+    }
+    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,
+    };
+}
+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;
+    }
+    list() {
+        return loadProfiles(this.layout);
+    }
+    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() };
+    }
+    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}`);
+        }
+    }
+    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,
+            };
+        }
+        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}`);
+        }
+        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;
+    }
+    takePreparedActiveReload(prepared) {
+        const state = this.preparedActiveReloads.get(prepared);
+        if (!state) {
+            throw new TypeError("Prepared active reload is invalid or already consumed");
+        }
+        this.preparedActiveReloads.delete(prepared);
+        return state;
+    }
+    preparedActiveReload(state) {
+        const prepared = opaqueToken();
+        this.preparedActiveReloads.set(prepared, state);
+        return prepared;
+    }
+    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 {
+            try {
+                rollbackConfig = { generated: await this.prepare(source.doc, rollbackSnapshot) };
+            }
+            catch (error) {
+                rollbackConfig = { error };
+            }
+        }
+        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 } : {}),
+        });
+        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");
+            }
+            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 },
+            }
+            : { 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);
+    }
+    async publish(index, opts = {}) {
+        await this.publishTransaction(index, opts);
+        this.notifyChange();
+    }
+    async addRemote(url, opts = {}) {
+        const normalizedUrl = url.trim();
+        if (!normalizedUrl)
+            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 } : {}),
+            };
+        });
+    }
+    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);
+            const now = new Date().toISOString();
+            const profile = {
+                id,
+                name: name.trim() || "imported",
+                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 } : {}) };
+        });
+    }
+    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 };
+    }
+    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);
+            const index = this.list();
+            const profile = this.recheckProfileSnapshot(index, snapshot, "Profile changed while editing");
+            const updated = {
+                ...profile,
+                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 } : {}) };
+        });
+    }
+    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)),
+            });
+        });
+    }
+    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)
+            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));
+        }
+        catch (err) {
+            await this.recordError(snapshot, err.message);
+            throw err;
+        }
+    }
+    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 });
+            }
+        }
+        return { updated, failed, ...(proxyCount !== undefined ? { proxyCount } : {}) };
+    }
+    async updateAll() {
+        const index = this.list();
+        return this.updateProfiles(index.profiles
+            .filter((profile) => profile.url !== "")
+            .map((profile) => this.updateSnapshot(profile, index.activeId)));
+    }
+    async updateDue(nowMs = Date.now()) {
+        const index = this.list();
+        return this.updateProfiles(index.profiles
+            .filter((profile) => {
+            let exists = false;
+            try {
+                exists = fs.existsSync(profileFilePath(this.layout, profile.id));
+            }
+            catch {
+            }
+            return profileDueForUpdate(profile, exists, nowMs);
+        })
+            .map((profile) => this.updateSnapshot(profile, index.activeId)));
+    }
+    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 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)),
+            });
+            return { profile: updated };
+        });
+    }
+}