dsh-plugin-subscriptions 0.5.2 → 0.6.0

package/lib/auth/store.d.ts

@@ -1,10 +1,16 @@
 /**
  * On-disk OAuth session store at `~/.dsh/plugins/subscriptions/auth.json`.
  *
- * The file is a JSON object keyed by provider id. Writes are atomic
- * (tmp file + rename) with mode 0600 because they carry bearer tokens.
- * Session shapes live here (not in the provider modules) because this file
- * owns the durable format.
+ * The file is a JSON object keyed by provider id, each entry holding that
+ * provider's ACCOUNTS: a map of account key → session plus the default
+ * account's key. Writes are atomic (tmp file + rename) with mode 0600
+ * because they carry bearer tokens. Session shapes live here (not in the
+ * provider modules) because this file owns the durable format.
+ *
+ * Backward compatibility: entries written by single-account versions hold
+ * the session fields directly (no `accounts` wrapper); reads migrate them
+ * in memory, and the next write persists the new shape — existing logins
+ * survive the upgrade untouched.
  */
 /** Provider routes this plugin can serve. */
 export type ProviderId = 'codex' | 'claude' | 'grok' | 'copilot';
@@ -34,6 +40,11 @@ export interface ClaudeSession {
     scopes: string;
     emailAddress?: string;
     subscriptionType?: string;
+    /**
+     * True when this account was imported from Claude Code's own credential
+     * store (Keychain/file): only bound accounts sync refreshes back to it.
+     */
+    keychainBound?: boolean;
 }
 /** Stored Grok (X Premium / xAI) subscription session. */
 export interface GrokSession {
@@ -64,15 +75,42 @@ export interface CopilotSession {
     /** GitHub login name, for the status display. */
     account?: string;
 }
-/** The durable store shape: one optional session per provider. */
+/** One provider's accounts: account key → session, plus the default account. */
+export interface ProviderAccounts<S> {
+    /** Key of the account direct (non-pool) routes serve; the first login wins. */
+    default?: string;
+    accounts: Record<string, S>;
+}
+/** The durable store shape: per provider, its accounts. */
 export interface SessionMap {
-    codex?: CodexSession;
-    claude?: ClaudeSession;
-    grok?: GrokSession;
-    copilot?: CopilotSession;
+    codex?: ProviderAccounts<CodexSession>;
+    claude?: ProviderAccounts<ClaudeSession>;
+    grok?: ProviderAccounts<GrokSession>;
+    copilot?: ProviderAccounts<CopilotSession>;
 }
 /** Any stored session, for provider-agnostic plumbing. */
 export type StoredSession = CodexSession | ClaudeSession | GrokSession | CopilotSession;
+/** The session type one provider stores. */
+export type SessionOf<K extends ProviderId> = NonNullable<SessionMap[K]>['accounts'][string];
+/** One account entry as returned by {@link listAccounts} (default first). */
+export interface AccountEntry<S> {
+    key: string;
+    session: S;
+}
+/**
+ * The stable identity of one session's account: codex keys on the always
+ * present `accountId` claim, the others on their display identity, falling
+ * back to a refresh-token hash for sessions stored before identity fields
+ * existed. Logging the same account in again lands on the same key, so a
+ * re-login updates in place instead of duplicating. (The hash fallback can
+ * miss that dedup once for a legacy session re-logged with a now-known
+ * identity — the duplicate is visible on the Settings page and can simply
+ * be logged out.)
+ * @param provider - the provider route.
+ * @param session - the session to key.
+ * @returns the account map key.
+ */
+export declare function accountKeyOf(provider: ProviderId, session: StoredSession): string;
 /**
  * Absolute path of the auth store file.
  * @returns `dshHomePath('plugins', 'subscriptions', 'auth.json')`.
@@ -81,28 +119,48 @@ export declare function authFilePath(): string;
 /**
  * Read the whole store. A missing file is an empty store; malformed JSON or a
  * malformed entry throws, because silently discarding tokens would strand the
- * user without a diagnosis.
+ * user without a diagnosis. Single-account entries are migrated in memory;
+ * the next write persists the new shape.
  * @param path - store file path; defaults to {@link authFilePath}.
  * @returns the parsed session map.
  */
 export declare function loadStore(path?: string): Promise<SessionMap>;
 /**
- * Read one provider's session.
+ * List one provider's accounts, default first.
+ * @param provider - the provider route.
+ * @param path - store file path; defaults to {@link authFilePath}.
+ * @returns the account entries in stable order (empty when logged out).
+ */
+export declare function listAccounts<K extends ProviderId>(provider: K, path?: string): Promise<AccountEntry<SessionOf<K>>[]>;
+/**
+ * Read one account's session.
  * @param provider - the provider route.
+ * @param account - the account key; defaults to the provider's default account.
  * @param path - store file path; defaults to {@link authFilePath}.
- * @returns the stored session, or `undefined` when logged out.
+ * @returns the stored session, or `undefined` when absent.
  */
-export declare function getSession<K extends ProviderId>(provider: K, path?: string): Promise<SessionMap[K] | undefined>;
+export declare function getAccountSession<K extends ProviderId>(provider: K, account?: string, path?: string): Promise<SessionOf<K> | undefined>;
 /**
- * Write one provider's session, preserving the others.
+ * Write one account's session, preserving the others. The first account of a
+ * provider becomes its default.
  * @param provider - the provider route.
+ * @param account - the account key (see {@link accountKeyOf}).
  * @param session - the fresh session from a login or refresh.
  * @param path - store file path; defaults to {@link authFilePath}.
  */
-export declare function saveSession<K extends ProviderId>(provider: K, session: NonNullable<SessionMap[K]>, path?: string): Promise<void>;
+export declare function saveAccountSession<K extends ProviderId>(provider: K, account: string, session: SessionOf<K>, path?: string): Promise<void>;
+/**
+ * Delete one account's session (logout). Deleting the default moves the badge
+ * to the next remaining account.
+ * @param provider - the provider route.
+ * @param account - the account key.
+ * @param path - store file path; defaults to {@link authFilePath}.
+ */
+export declare function deleteAccountSession(provider: ProviderId, account: string, path?: string): Promise<void>;
 /**
- * Delete one provider's session (logout).
+ * Pin the account direct (non-pool) routes serve.
  * @param provider - the provider route.
+ * @param account - the account key; must exist.
  * @param path - store file path; defaults to {@link authFilePath}.
  */
-export declare function deleteSession(provider: ProviderId, path?: string): Promise<void>;
+export declare function setDefaultAccount(provider: ProviderId, account: string, path?: string): Promise<void>;

package/lib/auth/store.js

@@ -1,16 +1,52 @@
 /**
  * On-disk OAuth session store at `~/.dsh/plugins/subscriptions/auth.json`.
  *
- * The file is a JSON object keyed by provider id. Writes are atomic
- * (tmp file + rename) with mode 0600 because they carry bearer tokens.
- * Session shapes live here (not in the provider modules) because this file
- * owns the durable format.
+ * The file is a JSON object keyed by provider id, each entry holding that
+ * provider's ACCOUNTS: a map of account key → session plus the default
+ * account's key. Writes are atomic (tmp file + rename) with mode 0600
+ * because they carry bearer tokens. Session shapes live here (not in the
+ * provider modules) because this file owns the durable format.
+ *
+ * Backward compatibility: entries written by single-account versions hold
+ * the session fields directly (no `accounts` wrapper); reads migrate them
+ * in memory, and the next write persists the new shape — existing logins
+ * survive the upgrade untouched.
  */
+import { createHash } from 'node:crypto';
 import { chmod, mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { dirname } from 'node:path';
 import { dshHomePath } from '@deepseek-ai/dsh-home-paths';
 /** Every provider route, in display order. */
 export const PROVIDER_IDS = ['codex', 'claude', 'grok', 'copilot'];
+/**
+ * The stable identity of one session's account: codex keys on the always
+ * present `accountId` claim, the others on their display identity, falling
+ * back to a refresh-token hash for sessions stored before identity fields
+ * existed. Logging the same account in again lands on the same key, so a
+ * re-login updates in place instead of duplicating. (The hash fallback can
+ * miss that dedup once for a legacy session re-logged with a now-known
+ * identity — the duplicate is visible on the Settings page and can simply
+ * be logged out.)
+ * @param provider - the provider route.
+ * @param session - the session to key.
+ * @returns the account map key.
+ */
+export function accountKeyOf(provider, session) {
+    switch (provider) {
+        case 'codex':
+            return session.accountId;
+        case 'claude':
+            return session.emailAddress ?? tokenHash(session.refreshToken);
+        case 'grok':
+            return session.account ?? tokenHash(session.refreshToken);
+        case 'copilot':
+            return session.account ?? tokenHash(session.refreshToken);
+    }
+}
+/** Short stable hash for sessions without an identity field. */
+function tokenHash(refreshToken) {
+    return `token-${createHash('sha256').update(refreshToken).digest('hex').slice(0, 16)}`;
+}
 /**
  * Absolute path of the auth store file.
  * @returns `dshHomePath('plugins', 'subscriptions', 'auth.json')`.
@@ -22,22 +58,23 @@ export function authFilePath() {
 function legacyAuthFilePath() {
     return dshHomePath('plugins', 'router', 'auth.json');
 }
-/** Check that one durable entry carries the fields every session needs. */
-function assertSessionShape(provider, value) {
+/** Check that one durable session carries the fields every session needs. */
+function assertSessionShape(provider, account, value) {
     if (typeof value !== 'object' || value === null) {
-        throw new Error(`subscriptions auth store: entry "${provider}" is not an object; fix or delete the store file`);
+        throw new Error(`subscriptions auth store: entry "${provider}/${account}" is not an object; fix or delete the store file`);
     }
     const entry = value;
     if (typeof entry.accessToken !== 'string' || entry.accessToken.length === 0
         || typeof entry.refreshToken !== 'string' || entry.refreshToken.length === 0
         || typeof entry.expiresAt !== 'number' || !Number.isFinite(entry.expiresAt)) {
-        throw new Error(`subscriptions auth store: entry "${provider}" is missing accessToken/refreshToken/expiresAt; fix or delete the store file`);
+        throw new Error(`subscriptions auth store: entry "${provider}/${account}" is missing accessToken/refreshToken/expiresAt; fix or delete the store file`);
     }
 }
 /**
  * Read the whole store. A missing file is an empty store; malformed JSON or a
  * malformed entry throws, because silently discarding tokens would strand the
- * user without a diagnosis.
+ * user without a diagnosis. Single-account entries are migrated in memory;
+ * the next write persists the new shape.
  * @param path - store file path; defaults to {@link authFilePath}.
  * @returns the parsed session map.
  */
@@ -67,7 +104,7 @@ export async function loadStore(path = authFilePath()) {
     }
     return parseStore(text, path);
 }
-/** Parse and validate store JSON read from `path`. */
+/** Parse, validate, and migrate store JSON read from `path`. */
 function parseStore(text, path) {
     let parsed;
     try {
@@ -79,11 +116,36 @@ function parseStore(text, path) {
     if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
         throw new Error(`subscriptions auth store at ${path} must be a JSON object keyed by provider; fix or delete the file`);
     }
-    const store = parsed;
+    const raw = parsed;
+    const store = {};
     for (const provider of PROVIDER_IDS) {
-        const entry = store[provider];
-        if (entry !== undefined)
-            assertSessionShape(provider, entry);
+        const entry = raw[provider];
+        if (entry === undefined)
+            continue;
+        if (typeof entry !== 'object' || entry === null || Array.isArray(entry)) {
+            throw new Error(`subscriptions auth store: entry "${provider}" is not an object; fix or delete the store file`);
+        }
+        const record = entry;
+        if (typeof record.accessToken === 'string') {
+            // Single-account format: wrap the bare session, preserving every field.
+            assertSessionShape(provider, '(legacy)', record);
+            const session = record;
+            const key = accountKeyOf(provider, session);
+            store[provider] = { default: key, accounts: { [key]: session } };
+            continue;
+        }
+        const accounts = record.accounts;
+        if (typeof accounts !== 'object' || accounts === null || Array.isArray(accounts)) {
+            throw new Error(`subscriptions auth store: entry "${provider}" has no accounts map; fix or delete the store file`);
+        }
+        if (record.default !== undefined && typeof record.default !== 'string') {
+            throw new Error(`subscriptions auth store: entry "${provider}" default is not a string; fix or delete the store file`);
+        }
+        for (const [account, session] of Object.entries(accounts)) {
+            assertSessionShape(provider, account, session);
+        }
+        ;
+        store[provider] = record;
     }
     return store;
 }
@@ -106,8 +168,8 @@ async function writeStore(store, path) {
 /**
  * One write chain per store path. Every mutation is a read-modify-write of a
  * single JSON file, and the plugin has several independent writers — a login,
- * a logout, and one token refresh per provider adapter, each on its own
- * schedule. Overlapping them unserialized costs whichever provider read the
+ * a logout, and one token refresh per provider account, each on its own
+ * schedule. Overlapping them unserialized costs whichever account read the
  * store first its entry.
  *
  * A chain is dropped once nothing is queued behind it, so the map holds an
@@ -136,38 +198,97 @@ async function serialize(path, action) {
     }
 }
 /**
- * Read one provider's session.
+ * List one provider's accounts, default first.
  * @param provider - the provider route.
  * @param path - store file path; defaults to {@link authFilePath}.
- * @returns the stored session, or `undefined` when logged out.
+ * @returns the account entries in stable order (empty when logged out).
  */
-export async function getSession(provider, path = authFilePath()) {
-    return (await loadStore(path))[provider];
+export async function listAccounts(provider, path = authFilePath()) {
+    const entry = (await loadStore(path))[provider];
+    if (entry === undefined)
+        return [];
+    const accounts = Object.entries(entry.accounts).map(([key, session]) => ({ key, session }));
+    accounts.sort((a, b) => Number(b.key === entry.default) - Number(a.key === entry.default));
+    return accounts;
 }
 /**
- * Write one provider's session, preserving the others.
+ * Read one account's session.
  * @param provider - the provider route.
+ * @param account - the account key; defaults to the provider's default account.
+ * @param path - store file path; defaults to {@link authFilePath}.
+ * @returns the stored session, or `undefined` when absent.
+ */
+export async function getAccountSession(provider, account, path = authFilePath()) {
+    const entry = (await loadStore(path))[provider];
+    if (entry === undefined)
+        return undefined;
+    const key = account ?? entry.default;
+    if (key === undefined)
+        return undefined;
+    return entry.accounts[key];
+}
+/**
+ * Write one account's session, preserving the others. The first account of a
+ * provider becomes its default.
+ * @param provider - the provider route.
+ * @param account - the account key (see {@link accountKeyOf}).
  * @param session - the fresh session from a login or refresh.
  * @param path - store file path; defaults to {@link authFilePath}.
  */
-export async function saveSession(provider, session, path = authFilePath()) {
+export async function saveAccountSession(provider, account, session, path = authFilePath()) {
     return serialize(path, async () => {
         const store = await loadStore(path);
-        store[provider] = session;
+        const entry = store[provider];
+        store[provider] = {
+            default: entry?.default ?? account,
+            accounts: { ...entry?.accounts, [account]: session },
+        };
         await writeStore(store, path);
     });
 }
 /**
- * Delete one provider's session (logout).
+ * Delete one account's session (logout). Deleting the default moves the badge
+ * to the next remaining account.
  * @param provider - the provider route.
+ * @param account - the account key.
  * @param path - store file path; defaults to {@link authFilePath}.
  */
-export async function deleteSession(provider, path = authFilePath()) {
+export async function deleteAccountSession(provider, account, path = authFilePath()) {
     return serialize(path, async () => {
         const store = await loadStore(path);
-        if (store[provider] === undefined)
+        const entry = store[provider];
+        if (entry === undefined || !(account in entry.accounts))
             return;
-        delete store[provider];
+        const accounts = { ...entry.accounts };
+        delete accounts[account];
+        if (Object.keys(accounts).length === 0) {
+            delete store[provider];
+        }
+        else {
+            ;
+            store[provider] = {
+                ...entry.default === account ? { default: Object.keys(accounts)[0] } : { default: entry.default },
+                accounts,
+            };
+        }
+        await writeStore(store, path);
+    });
+}
+/**
+ * Pin the account direct (non-pool) routes serve.
+ * @param provider - the provider route.
+ * @param account - the account key; must exist.
+ * @param path - store file path; defaults to {@link authFilePath}.
+ */
+export async function setDefaultAccount(provider, account, path = authFilePath()) {
+    return serialize(path, async () => {
+        const store = await loadStore(path);
+        const entry = store[provider];
+        if (entry === undefined || !(account in entry.accounts)) {
+            throw new Error(`no ${provider} account "${account}" is logged in`);
+        }
+        ;
+        store[provider] = { ...entry, default: account };
         await writeStore(store, path);
     });
 }

package/lib/client/ImageGenerateToolview.d.ts

@@ -1,5 +1,5 @@
 import type { ConnectionHandle } from '@deepseek-ai/dsh-api-remotes/client';
-import type { ToolCallBlock } from '@deepseek-ai/dsh-client-runtime/client';
+import type { ToolCallBlock } from '@deepseek-ai/dsh-client-ui-conversation/client';
 import type { ImageLoader } from './ImageGallery.js';
 import type { SubscriptionsKey } from './locales.js';
 /** Mirror of ui-tool's ToolCallOwnerProps (see the module header). */

package/lib/client/SpeedSelect.d.ts

@@ -12,6 +12,25 @@ export interface SpeedSelectState {
     visible: boolean;
     tier: SpeedTier;
 }
+/**
+ * Minimal structural face of ui-model-selection's `ctx.modelDirectories`
+ * service (the sanctioned cross-plugin channel: cordis services, not value
+ * imports — same mirroring discipline as ToolCallOwnerProps). Both dsh lines
+ * ship it with this shape; it replaces rc.2's `connection.api.sessions.models`
+ * read, which the 0.1.2-alpha removed along with the whole `.api` face.
+ */
+export interface ModelDirectoriesLike {
+    /** Resolve one session's shared model directory (throws for unknown sessions). */
+    directoryFor(sessionId: string): {
+        /** Load the directory; `current` is the session's effective model selection. */
+        load(): Promise<{
+            current: {
+                provider: string;
+                model: string;
+            } | null;
+        }>;
+    };
+}
 /** Injected dependencies of {@link SpeedSelect} (slot `inject`, session-bound). */
 export interface SpeedSelectInjected {
     /** Load the session's speed state; `visible` false keeps the control hidden. */
@@ -32,9 +51,13 @@ export type SpeedSelectProps = PropsRuntime<'conversation.input.right'> & Partia
  * known state, so a transient failure never locks the toggle away.
  *
  * `sessionId` is a plain string: slot and command contexts brand it through
- * different dsh-session copies, and only the API-client boundary needs one.
+ * different dsh-session copies, and only the service boundary needs one.
+ *
+ * `models` resolves lazily per call: the ui-model-selection service may
+ * register after this plugin applies, and a shell without it (no model seat
+ * at all) simply keeps the toggle hidden.
  */
-export declare function createSpeedLoader(connection: ConnectionHandle, sessionId: string): SpeedSelectInjected['loadSpeed'];
+export declare function createSpeedLoader(connection: ConnectionHandle, models: () => ModelDirectoriesLike | undefined, sessionId: string): SpeedSelectInjected['loadSpeed'];
 /** The `setSpeed` half of the inject face: boolean outcome for the component's busy state. */
 export declare function createSpeedSetter(connection: ConnectionHandle, sessionId: string): SpeedSelectInjected['setSpeed'];
 /**

package/lib/client/SpeedSelect.js

@@ -22,15 +22,19 @@ import { en } from './locales.js';
  * known state, so a transient failure never locks the toggle away.
  *
  * `sessionId` is a plain string: slot and command contexts brand it through
- * different dsh-session copies, and only the API-client boundary needs one.
+ * different dsh-session copies, and only the service boundary needs one.
+ *
+ * `models` resolves lazily per call: the ui-model-selection service may
+ * register after this plugin applies, and a shell without it (no model seat
+ * at all) simply keeps the toggle hidden.
  */
-export function createSpeedLoader(connection, sessionId) {
+export function createSpeedLoader(connection, models, sessionId) {
     return async () => {
         const state = await callSubscriptionsAuth(connection.rpc, 'speed', { sessionId });
-        const { result } = await connection.api.sessions.models({ sessionId: sessionId });
-        if (!result.ok)
-            throw new Error(`session.models failed: ${result.error.code}: ${result.error.message}`);
-        const current = result.value.current;
+        const directories = models();
+        if (directories === undefined)
+            return { visible: false, tier: state.tier };
+        const { current } = await directories.directoryFor(sessionId).load();
         const visible = current !== null && current.provider === 'codex'
             && state.fastModels.includes(current.model);
         return { visible, tier: state.tier };

package/lib/client/SubscriptionsSection.d.ts

@@ -2,12 +2,18 @@ import type { ConnectionHandle } from '@deepseek-ai/dsh-api-remotes/client';
 import type { SubscriptionsKey } from './locales.js';
 /** Subscription provider ids, fixed by the node half's OAuth adapters. */
 export type SubscriptionProvider = 'codex' | 'claude' | 'grok' | 'copilot';
+/** One logged-in account as answered by the `status` endpoint. */
+export interface AccountStatus {
+    key: string;
+    account?: string;
+    expiresAt?: number;
+    plan?: string;
+    isDefault: boolean;
+}
 /** One provider's login state as answered by the `status` endpoint. */
 export interface ProviderStatus {
-    loggedIn: boolean;
     busy: boolean;
-    expiresAt?: number;
-    account?: string;
+    accounts: AccountStatus[];
     detail?: string;
 }
 /** One rate-limit window as answered by the `usage` endpoint. */
@@ -23,6 +29,23 @@ export interface ProviderUsage {
     windows?: UsageWindow[];
     plan?: string;
 }
+/** One model's default-effort picker state as answered by `modelDefaults`. */
+export interface ModelDefaultView {
+    id: string;
+    name: string;
+    /** Advertised effort levels, in catalog order (empty when the model has no reasoning). */
+    efforts: {
+        id: string;
+        name: string;
+    }[];
+    /** The user-configured default effort, when set. */
+    configured?: string;
+}
+/** `modelDefaults` endpoint value: one provider's picker state. */
+export interface ModelDefaultsCatalog {
+    provider: SubscriptionProvider;
+    models: ModelDefaultView[];
+}
 /** `proxyGet` endpoint value: the node half owns this shape (no secrets). */
 export interface ProxyConfigView {
     enabled: boolean;
@@ -61,6 +84,63 @@ export type SubscriptionsSectionProps = Partial<SubscriptionsSectionInjected>;
  * @returns the success value, cast by the caller to the endpoint's shape.
  */
 export declare function callSubscriptionsAuth<T>(rpc: ConnectionHandle['rpc'], endpoint: string, payload: unknown): Promise<T>;
+/** What one provider's collapsible default-effort section renders. */
+export interface ModelDefaultsView {
+    /** Models with reasoning levels, after the name filter — one row each. */
+    shown: ModelDefaultView[];
+    /** Models with reasoning levels before filtering (the header total). */
+    total: number;
+    /** How many of those carry a user override (the header count). */
+    overridden: number;
+    /** Models without reasoning levels: one count line, never a row each. */
+    withoutEfforts: number;
+    /** Whether the list is long enough to deserve a filter box. */
+    showFilter: boolean;
+}
+/**
+ * Derive one provider's default-effort section from its catalog and filter.
+ * Pure so the collapsed-header counts and the filter stay testable without a
+ * DOM: rows come only from models that advertise levels, the count of the rest
+ * rides as one line, and the filter matches display name or model id.
+ * @param models - the provider's catalog models, or undefined while loading.
+ * @param filter - the raw filter input (trimmed and lowercased here).
+ * @returns the section's rows and header counts.
+ */
+export declare function deriveModelDefaultsView(models: readonly ModelDefaultView[] | undefined, filter: string): ModelDefaultsView;
+/** Inputs of the default-effort fetch decision (see {@link shouldFetchModelDefaults}). */
+export interface ModelDefaultsFetchInput {
+    /** Providers that currently have at least one account. */
+    loggedIn: readonly SubscriptionProvider[];
+    /** Providers whose disclosure is open. */
+    open: readonly SubscriptionProvider[];
+    /** The account signature the last completed fetch was answered for. */
+    loadedFor: string | undefined;
+    /** The account signature of the current status snapshot. */
+    signature: string;
+    /** Whether the last attempt failed (a failure latches until Retry). */
+    failed: boolean;
+}
+/**
+ * Whether the default-effort catalog needs (re)fetching.
+ *
+ * Fetching is gated on an *attempt* signature rather than on the payload
+ * being empty: an empty answer is a legitimate result (a narrowed
+ * `config.providers`, or a catalog that is momentarily unavailable), and
+ * treating it as "not loaded yet" re-ran this effect forever. The signature
+ * also covers the accounts, so logging a second provider in refetches
+ * instead of leaving that card on the previous answer.
+ * @param input - the decision inputs.
+ * @returns true when the caller should start a fetch.
+ */
+export declare function shouldFetchModelDefaults(input: ModelDefaultsFetchInput): boolean;
+/**
+ * Stable signature of the accounts a catalog answer depends on. A change
+ * means a previous answer is stale (an account arrived or left), so the next
+ * open disclosure refetches.
+ * @param statuses - the per-provider status snapshot.
+ * @returns a signature string, stable across renders with equal accounts.
+ */
+export declare function modelDefaultsSignature(statuses: Partial<Record<SubscriptionProvider, ProviderStatus>>): string;
 /**
  * The Subscriptions settings page component.
  * @param props - the slot inject face ({@link SubscriptionsSectionInjected}).