@cortexkit/anthropic-auth-core 1.22.0 → 2.0.0

package/dist/routing.js

@@ -1,94 +0,0 @@
-import { createEmptyStorage, getAccountStoragePath, loadAccounts, saveAccounts, } from './accounts.js';
-export const CLAUDE_ROUTING_COMMAND_NAME = 'claude-routing';
-export const ROUTING_MODES = [
-    'main-first',
-    'fallback-first',
-    'sticky-balanced',
-];
-export const DEFAULT_ROUTING_MODE = 'main-first';
-const ROUTING_USAGE = 'Usage: `/claude-routing`, `/claude-routing main-first`, `/claude-routing fallback-first`, `/claude-routing sticky-balanced`, or `/claude-routing reset`.';
-function normalizeRoutingMode(value) {
-    return typeof value === 'string' &&
-        ROUTING_MODES.includes(value)
-        ? value
-        : DEFAULT_ROUTING_MODE;
-}
-export function getRoutingMode(storage) {
-    return normalizeRoutingMode(storage?.routing?.mode);
-}
-export async function setRoutingMode(mode, path = getAccountStoragePath()) {
-    const storage = (await loadAccounts(path)) ?? createEmptyStorage();
-    storage.routing = {
-        ...(storage.routing ?? {}),
-        mode,
-    };
-    await saveAccounts(storage, path);
-    return storage;
-}
-export function parseRoutingCommandAction(argumentsText) {
-    const tokens = argumentsText.trim().toLowerCase().split(/\s+/).filter(Boolean);
-    if (tokens.length === 0)
-        return { type: 'status' };
-    if (tokens.length === 1 && tokens[0] === 'reset')
-        return { type: 'reset' };
-    if (tokens.length === 1 && ROUTING_MODES.includes(tokens[0])) {
-        return { type: 'mode', mode: tokens[0] };
-    }
-    if (tokens.length === 2 &&
-        tokens[0] === 'mode' &&
-        ROUTING_MODES.includes(tokens[1])) {
-        return { type: 'mode', mode: tokens[1] };
-    }
-    return { type: 'usage' };
-}
-function routingDescription(mode) {
-    if (mode === 'fallback-first') {
-        return 'Try usable fallback accounts before the main account. If no fallback succeeds, try the main account.';
-    }
-    if (mode === 'sticky-balanced') {
-        return 'Assign each session to a quota-weighted OAuth account, keep it sticky across transient failures, and migrate only for confirmed long-lived exhaustion or permanent account failure.';
-    }
-    return 'Try the main account first. Use fallback accounts only when quota policy or fallback errors require it.';
-}
-export function buildRoutingStatusSummary(input) {
-    const mode = input?.mode ?? DEFAULT_ROUTING_MODE;
-    return [
-        '## Claude Routing Status',
-        '',
-        `- Mode: \`${mode}\``,
-        `- Behavior: ${routingDescription(mode)}`,
-        '',
-        ROUTING_USAGE,
-    ].join('\n');
-}
-export function executeRoutingCommand(input) {
-    const action = parseRoutingCommandAction(input.argumentsText);
-    const mode = input.mode ?? DEFAULT_ROUTING_MODE;
-    if (action.type === 'status')
-        return buildRoutingStatusSummary({ mode });
-    if (action.type === 'mode') {
-        return [
-            '## Claude Routing Updated',
-            '',
-            `Mode updated to \`${action.mode}\`.`,
-            '',
-            ...buildRoutingStatusSummary({ mode: action.mode }).split('\n').slice(2),
-        ].join('\n');
-    }
-    if (action.type === 'reset') {
-        return [
-            '## Claude Routing Assignment Reset',
-            '',
-            'The current session will be assigned again on its next request.',
-            '',
-            ...buildRoutingStatusSummary({ mode }).split('\n').slice(2),
-        ].join('\n');
-    }
-    return [
-        '## Claude Routing Usage',
-        '',
-        ROUTING_USAGE,
-        '',
-        ...buildRoutingStatusSummary({ mode }).split('\n').slice(2),
-    ].join('\n');
-}

package/dist/start.js

@@ -1,29 +0,0 @@
-export const CLAUDE_START_COMMAND_NAME = 'claude-start';
-const START_STATUS_TITLE = '## Claude Lane Start Status';
-const START_QUEUED_TITLE = '## Claude Lane Start Queued';
-const START_USAGE_TITLE = '## Claude Lane Start Usage';
-const START_USAGE = 'Usage: `/claude-start`.';
-export function parseLaneStartCommandAction(input) {
-    const normalized = input.trim().split(/\s+/).filter(Boolean);
-    if (normalized.length === 0)
-        return { type: 'fire' };
-    return { type: 'usage' };
-}
-export function executeLaneStartCommand(input) {
-    const action = parseLaneStartCommandAction(input.argumentsText);
-    if (action.type === 'fire') {
-        return {
-            action,
-            text: [
-                START_QUEUED_TITLE,
-                '',
-                '- Queued an explicit lane-start request.',
-                '- This is a billed request: the one-token limit does not remove prompt-cache read or write charges.',
-            ].join('\n'),
-        };
-    }
-    return {
-        action,
-        text: [START_USAGE_TITLE, '', START_USAGE, '', START_STATUS_TITLE].join('\n'),
-    };
-}

package/dist/sticky-routing.js

@@ -1,523 +0,0 @@
-import { createHash, randomUUID } from 'node:crypto';
-import { mkdir, readFile, rename, rm, stat, writeFile } from 'node:fs/promises';
-import { basename, dirname, join } from 'node:path';
-import { acquireRefreshFileLock, getKillswitchThresholdsForAccount, getQuotaCheckIntervalMs, getQuotaMinimumRemainingThresholds, getScopedQuotaWindowForModel, isKillswitchEnabled, isPermanentRefreshError, killswitchRetryAfterSeconds, quotaSnapshotPassesModelScope, } from './accounts.js';
-import { isClaudeFableOrMythos5Model } from './models.js';
-export const STICKY_ROUTING_MAIN_ACCOUNT_ID = 'main';
-export const STICKY_ROUTING_SHORT_RESET_GRACE_MS = 15 * 60_000;
-export const STICKY_ROUTING_ASSIGNMENT_TTL_MS = 7 * 24 * 60 * 60_000;
-const STICKY_ROUTING_TOUCH_INTERVAL_MS = 60 * 60_000;
-const STICKY_ROUTING_LOCK_TTL_MS = 10_000;
-const STICKY_ROUTING_LOCK_WAIT_MS = 5_000;
-const STICKY_ROUTING_LOCK_POLL_MS = 10;
-const STICKY_ROUTING_MAX_ASSIGNMENTS = 4_096;
-const MIN_WEIGHT = 0.000_001;
-/**
- * Build the terminal response for a complete sticky quota pool that has no
- * eligible route. This prevents callers from silently falling through to the
- * main account after the router deliberately excluded it.
- */
-export function createStickyNoRouteResponse(input) {
-    const modelId = input.modelId;
-    const modelName = modelId
-        ? input.routeQuotas
-            .map((quota) => getScopedQuotaWindowForModel(quota, modelId))
-            .find(Boolean)?.modelName
-        : undefined;
-    let authenticationMessage;
-    if (isPermanentRefreshError(input.mainRefreshError)) {
-        authenticationMessage = modelName
-            ? `Main Claude OAuth account requires re-login, and no fallback OAuth account is currently routable for ${modelName}.`
-            : 'Main Claude OAuth account requires re-login, and no fallback OAuth account is currently routable.';
-    }
-    else if (input.fallbackReauthLabels?.length) {
-        const scope = modelName ? ` for ${modelName}` : '';
-        authenticationMessage = `No OAuth account is currently routable${scope}. Fallback Claude OAuth accounts require re-login: ${input.fallbackReauthLabels.join(', ')}.`;
-    }
-    if (authenticationMessage) {
-        return new Response(JSON.stringify({
-            type: 'error',
-            error: {
-                type: 'authentication_error',
-                message: authenticationMessage,
-            },
-        }), {
-            status: 401,
-            headers: { 'content-type': 'application/json' },
-        });
-    }
-    const scopedBlocked = Boolean(modelId &&
-        input.routeQuotas.length > 0 &&
-        input.routeQuotas.every((quota) => !quotaSnapshotPassesModelScope(quota, modelId)));
-    const [firstQuota, ...remainingQuotas] = input.routeQuotas;
-    const retryAfter = killswitchRetryAfterSeconds(firstQuota, remainingQuotas.map((quota) => ({ quota })), input.now ?? Date.now(), scopedBlocked ? modelId : undefined);
-    const minutes = Math.floor(retryAfter / 60);
-    const seconds = retryAfter % 60;
-    const reason = scopedBlocked && modelName
-        ? `${modelName} weekly limit reached, no routable OAuth accounts.`
-        : 'No OAuth account currently satisfies sticky-balanced quota policy.';
-    const message = `${reason} Retry in ${minutes}m ${seconds}s.`;
-    return new Response(JSON.stringify({
-        type: 'error',
-        error: { type: 'rate_limit_error', message },
-    }), {
-        status: 429,
-        headers: {
-            'content-type': 'application/json',
-            'retry-after': String(retryAfter),
-        },
-    });
-}
-function isRecord(value) {
-    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
-}
-function finiteNumber(value) {
-    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
-}
-function normalizeAssignment(value) {
-    if (!isRecord(value))
-        return;
-    if (typeof value.accountId !== 'string' ||
-        !['fable', 'opus', 'general'].includes(String(value.family))) {
-        return;
-    }
-    const assignedAt = finiteNumber(value.assignedAt);
-    const lastSeenAt = finiteNumber(value.lastSeenAt);
-    const initialInputBytes = finiteNumber(value.initialInputBytes);
-    const quotaCheckedAt = finiteNumber(value.quotaCheckedAt);
-    if (assignedAt === undefined ||
-        lastSeenAt === undefined ||
-        initialInputBytes === undefined ||
-        quotaCheckedAt === undefined) {
-        return;
-    }
-    return {
-        accountId: value.accountId,
-        family: value.family,
-        assignedAt,
-        lastSeenAt,
-        initialInputBytes: Math.max(0, initialInputBytes),
-        quotaCheckedAt,
-    };
-}
-function normalizeState(value) {
-    if (!isRecord(value) || value.version !== 1 || !isRecord(value.assignments)) {
-        return;
-    }
-    const assignments = {};
-    for (const [key, assignment] of Object.entries(value.assignments)) {
-        const normalized = normalizeAssignment(assignment);
-        if (normalized)
-            assignments[key] = normalized;
-    }
-    return {
-        version: 1,
-        updatedAt: finiteNumber(value.updatedAt) ?? 0,
-        assignments,
-    };
-}
-function emptyState(now) {
-    return { version: 1, updatedAt: now, assignments: {} };
-}
-function sessionKey(sessionId) {
-    return createHash('sha256').update(sessionId).digest('hex');
-}
-export function stickyQuotaSnapshotIsFresh(quota, storage, now = Date.now(), modelId) {
-    const maxAge = getQuotaCheckIntervalMs(storage);
-    const standardFresh = ['five_hour', 'seven_day'].every((key) => {
-        const window = quota?.[key];
-        return Boolean(window && now - window.checkedAt < maxAge);
-    });
-    if (!standardFresh)
-        return false;
-    const scoped = getScopedQuotaWindowForModel(quota, modelId);
-    return !scoped || now - scoped.checkedAt < maxAge;
-}
-function snapshotCheckedAt(quota) {
-    return Math.max(quota.checkedAt ?? 0, quota.five_hour?.checkedAt ?? 0, quota.seven_day?.checkedAt ?? 0, ...(quota.scoped ?? []).map((window) => window.checkedAt ?? 0));
-}
-function knownQuota(quota) {
-    if (!quota)
-        return undefined;
-    if ('kind' in quota)
-        return quota.kind === 'known' ? quota.quota : undefined;
-    return quota;
-}
-function remainingThreshold(storage, accountId, key) {
-    const quotaMinimum = getQuotaMinimumRemainingThresholds(storage);
-    const quotaThreshold = key === 'five_hour'
-        ? quotaMinimum.five_hour
-        : key === 'seven_day'
-            ? quotaMinimum.seven_day
-            : 0;
-    if (!isKillswitchEnabled(storage))
-        return quotaThreshold;
-    const killswitch = getKillswitchThresholdsForAccount(storage, accountId === STICKY_ROUTING_MAIN_ACCOUNT_ID ? undefined : accountId);
-    return Math.max(quotaThreshold, killswitch[key]);
-}
-function sustainableWindowWeight(remainingPercent, reservePercent, resetsAt, now) {
-    const spendable = Math.max(0, remainingPercent - reservePercent);
-    if (spendable <= 0)
-        return 0;
-    if (!resetsAt)
-        return spendable;
-    const resetAt = Date.parse(resetsAt);
-    if (!Number.isFinite(resetAt) || resetAt <= now)
-        return spendable;
-    const hoursUntilReset = Math.max((resetAt - now) / 3_600_000, 1 / 60);
-    return spendable / hoursUntilReset;
-}
-export function stickyRouteFamilyForModel(model) {
-    if (isClaudeFableOrMythos5Model(model))
-        return 'fable';
-    return typeof model === 'string' && model.toLowerCase().includes('opus')
-        ? 'opus'
-        : 'general';
-}
-export function stickyRouteCandidateWeight(input) {
-    const now = input.now ?? Date.now();
-    const { candidate, storage } = input;
-    const quota = knownQuota(candidate.quota);
-    if (!quota)
-        return 0;
-    if (!stickyQuotaSnapshotIsFresh(quota, storage, now, input.modelId)) {
-        return 0;
-    }
-    const weights = [];
-    for (const key of ['five_hour', 'seven_day']) {
-        const window = quota[key];
-        if (!window || !Number.isFinite(window.remainingPercent))
-            return 0;
-        weights.push(sustainableWindowWeight(window.remainingPercent, remainingThreshold(storage, candidate.accountId, key), window.resetsAt, now));
-    }
-    if (input.family === 'fable') {
-        const window = getScopedQuotaWindowForModel(quota, input.modelId);
-        if (window && Number.isFinite(window.remainingPercent)) {
-            weights.push(sustainableWindowWeight(window.remainingPercent, remainingThreshold(storage, candidate.accountId, 'scoped'), window.resetsAt, now));
-        }
-    }
-    return Math.min(...weights);
-}
-export function stickyRouteKnownFableExhausted(candidate, storage, now = Date.now()) {
-    const quota = knownQuota(candidate.quota);
-    const window = getScopedQuotaWindowForModel(quota, 'claude-fable-5');
-    return Boolean(window &&
-        stickyQuotaSnapshotIsFresh(quota, storage, now, 'claude-fable-5') &&
-        Number.isFinite(window.remainingPercent) &&
-        window.remainingPercent <= 0);
-}
-export function decideStickyQuotaFailure(input) {
-    const now = input.now ?? Date.now();
-    const quota = knownQuota(input.quota);
-    if (!quota)
-        return { action: 'retain', reason: 'unknown' };
-    const scoped = getScopedQuotaWindowForModel(quota, input.modelId);
-    if (scoped &&
-        Number.isFinite(scoped.remainingPercent) &&
-        scoped.remainingPercent <= 0) {
-        return { action: 'migrate', reason: 'model-scoped' };
-    }
-    const sevenDay = quota.seven_day;
-    if (sevenDay &&
-        Number.isFinite(sevenDay.remainingPercent) &&
-        sevenDay.remainingPercent <= 0) {
-        return { action: 'migrate', reason: 'seven-day' };
-    }
-    const fiveHour = quota.five_hour;
-    if (fiveHour &&
-        Number.isFinite(fiveHour.remainingPercent) &&
-        fiveHour.remainingPercent <= 0) {
-        const resetAt = fiveHour.resetsAt ? Date.parse(fiveHour.resetsAt) : NaN;
-        if (Number.isFinite(resetAt) &&
-            resetAt > now &&
-            resetAt - now <= STICKY_ROUTING_SHORT_RESET_GRACE_MS) {
-            return {
-                action: 'hold',
-                reason: 'five-hour-short-reset',
-                retryAfterSeconds: Math.max(1, Math.ceil((resetAt - now) / 1000)),
-            };
-        }
-        return { action: 'migrate', reason: 'five-hour' };
-    }
-    return { action: 'retain', reason: 'not-exhausted' };
-}
-export function getStickyRoutingStatePath(accountStoragePath) {
-    const name = basename(accountStoragePath);
-    const stem = name.endsWith('.json') ? name.slice(0, -5) : name;
-    return join(dirname(accountStoragePath), `${stem}-routing-state.json`);
-}
-export function stickyRetryAfterWithJitter(sessionId, retryAfterSeconds) {
-    const hash = createHash('sha256').update(sessionId).digest().readUInt32BE(0);
-    return Math.max(1, Math.ceil(retryAfterSeconds)) + (hash % 21);
-}
-export class StickySessionRouter {
-    options;
-    loaded = false;
-    state;
-    stateMtimeNs;
-    touchChain = Promise.resolve();
-    constructor(options) {
-        this.options = options;
-        this.state = emptyState(this.now());
-    }
-    now() {
-        return this.options.now?.() ?? Date.now();
-    }
-    async readState() {
-        try {
-            const raw = await readFile(this.options.path, 'utf8');
-            const normalized = normalizeState(JSON.parse(raw));
-            if (!normalized) {
-                throw new Error(`Invalid sticky routing state at ${this.options.path}`);
-            }
-            return normalized;
-        }
-        catch (error) {
-            if (error.code === 'ENOENT') {
-                return emptyState(this.now());
-            }
-            throw error;
-        }
-    }
-    async readStateMtimeNs() {
-        try {
-            return (await stat(this.options.path, { bigint: true })).mtimeNs;
-        }
-        catch (error) {
-            if (error.code === 'ENOENT')
-                return 0n;
-            throw error;
-        }
-    }
-    async refreshStateIfChanged() {
-        for (let attempt = 0; attempt < 3; attempt++) {
-            const before = await this.readStateMtimeNs();
-            if (this.loaded && before === this.stateMtimeNs)
-                return;
-            const state = await this.readState();
-            const after = await this.readStateMtimeNs();
-            if (before !== after)
-                continue;
-            this.state = state;
-            this.stateMtimeNs = after;
-            this.loaded = true;
-            return;
-        }
-        this.state = await this.readState();
-        this.stateMtimeNs = await this.readStateMtimeNs();
-        this.loaded = true;
-    }
-    async acquireLock() {
-        await mkdir(dirname(this.options.path), { recursive: true, mode: 0o700 });
-        const deadline = this.now() + STICKY_ROUTING_LOCK_WAIT_MS;
-        while (true) {
-            const lock = await acquireRefreshFileLock({
-                name: 'write',
-                path: this.options.path,
-                ttlMs: STICKY_ROUTING_LOCK_TTL_MS,
-                renew: true,
-            });
-            if (lock)
-                return lock;
-            if (this.now() >= deadline) {
-                throw new Error('Timed out acquiring sticky routing state lock');
-            }
-            await new Promise((resolve) => setTimeout(resolve, STICKY_ROUTING_LOCK_POLL_MS));
-        }
-    }
-    assignmentIsActive(assignment) {
-        return (assignment.lastSeenAt >=
-            this.now() -
-                (this.options.assignmentTtlMs ?? STICKY_ROUTING_ASSIGNMENT_TTL_MS));
-    }
-    prune(state) {
-        const cutoff = this.now() -
-            (this.options.assignmentTtlMs ?? STICKY_ROUTING_ASSIGNMENT_TTL_MS);
-        for (const [key, assignment] of Object.entries(state.assignments)) {
-            if (assignment.lastSeenAt < cutoff)
-                delete state.assignments[key];
-        }
-        const entries = Object.entries(state.assignments);
-        if (entries.length <= STICKY_ROUTING_MAX_ASSIGNMENTS)
-            return;
-        entries
-            .sort((left, right) => right[1].lastSeenAt - left[1].lastSeenAt)
-            .slice(STICKY_ROUTING_MAX_ASSIGNMENTS)
-            .forEach(([key]) => {
-            delete state.assignments[key];
-        });
-    }
-    async writeState(state) {
-        this.prune(state);
-        state.updatedAt = this.now();
-        const tempPath = `${this.options.path}.${randomUUID()}.tmp`;
-        try {
-            await writeFile(tempPath, `${JSON.stringify(state)}\n`, { mode: 0o600 });
-            await rename(tempPath, this.options.path);
-        }
-        finally {
-            await rm(tempPath, { force: true }).catch(() => { });
-        }
-        this.state = state;
-        this.stateMtimeNs = await this.readStateMtimeNs();
-        this.loaded = true;
-    }
-    scheduleTouch(key) {
-        this.touchChain = this.touchChain
-            .catch(() => { })
-            .then(async () => {
-            const lock = await this.acquireLock();
-            try {
-                const state = await this.readState();
-                const assignment = state.assignments[key];
-                if (!assignment)
-                    return;
-                assignment.lastSeenAt = this.now();
-                await this.writeState(state);
-            }
-            finally {
-                await lock.release();
-            }
-        })
-            .catch(() => { });
-    }
-    selectCandidate(input) {
-        let candidates = [...input.candidates];
-        if (input.family === 'opus') {
-            const depleted = candidates.filter((candidate) => stickyRouteKnownFableExhausted(candidate, input.storage, this.now()));
-            if (depleted.length > 0)
-                candidates = depleted;
-        }
-        const weighted = candidates.flatMap((candidate) => {
-            const weight = stickyRouteCandidateWeight({
-                candidate,
-                family: input.family,
-                modelId: input.modelId,
-                storage: input.storage,
-                now: this.now(),
-            });
-            return weight > 0 ? [{ candidate, weight }] : [];
-        });
-        if (weighted.length === 0 &&
-            candidates.every((candidate) => !knownQuota(candidate.quota))) {
-            return [...candidates].sort((left, right) => left.order - right.order ||
-                left.accountId.localeCompare(right.accountId))[0];
-        }
-        const pendingBytes = new Map();
-        for (const assignment of Object.values(input.state.assignments)) {
-            const candidate = weighted.find((entry) => entry.candidate.accountId === assignment.accountId)?.candidate;
-            if (!candidate)
-                continue;
-            const quota = knownQuota(candidate.quota);
-            if (quota && assignment.quotaCheckedAt !== snapshotCheckedAt(quota))
-                continue;
-            pendingBytes.set(assignment.accountId, (pendingBytes.get(assignment.accountId) ?? 0) +
-                assignment.initialInputBytes);
-        }
-        return weighted
-            .map(({ candidate, weight }) => ({
-            candidate,
-            score: ((pendingBytes.get(candidate.accountId) ?? 0) + input.inputBytes) /
-                Math.max(weight, MIN_WEIGHT),
-        }))
-            .sort((left, right) => left.score - right.score ||
-            left.candidate.order - right.candidate.order ||
-            left.candidate.accountId.localeCompare(right.candidate.accountId))[0]?.candidate;
-    }
-    async resolve(input) {
-        if (!input.sessionId)
-            return null;
-        await this.refreshStateIfChanged();
-        const key = sessionKey(input.sessionId);
-        const cached = this.state.assignments[key];
-        if (cached &&
-            this.assignmentIsActive(cached) &&
-            input.retainAccountIds.has(cached.accountId) &&
-            !input.excludeAccountIds?.has(cached.accountId)) {
-            if (this.now() - cached.lastSeenAt >= STICKY_ROUTING_TOUCH_INTERVAL_MS) {
-                cached.lastSeenAt = this.now();
-                this.scheduleTouch(key);
-            }
-            return {
-                accountId: cached.accountId,
-                assignment: { ...cached },
-                created: false,
-                migrated: false,
-            };
-        }
-        const lock = await this.acquireLock();
-        try {
-            const state = await this.readState();
-            this.prune(state);
-            const current = state.assignments[key];
-            if (current &&
-                input.retainAccountIds.has(current.accountId) &&
-                !input.excludeAccountIds?.has(current.accountId)) {
-                current.lastSeenAt = this.now();
-                await this.writeState(state);
-                return {
-                    accountId: current.accountId,
-                    assignment: { ...current },
-                    created: false,
-                    migrated: false,
-                };
-            }
-            const candidates = input.candidates.filter((candidate) => !input.excludeAccountIds?.has(candidate.accountId));
-            const preferred = input.preferredAccountId
-                ? candidates.find((candidate) => candidate.accountId === input.preferredAccountId &&
-                    stickyRouteCandidateWeight({
-                        candidate,
-                        family: input.family,
-                        modelId: input.modelId,
-                        storage: input.storage,
-                        now: this.now(),
-                    }) > 0)
-                : undefined;
-            const selected = preferred ?? this.selectCandidate({ ...input, candidates, state });
-            if (!selected) {
-                if (current) {
-                    delete state.assignments[key];
-                    await this.writeState(state);
-                }
-                return null;
-            }
-            const now = this.now();
-            const selectedQuota = knownQuota(selected.quota);
-            const assignment = {
-                accountId: selected.accountId,
-                family: input.family,
-                assignedAt: now,
-                lastSeenAt: now,
-                initialInputBytes: Math.max(1, input.inputBytes),
-                quotaCheckedAt: selectedQuota ? snapshotCheckedAt(selectedQuota) : 0,
-            };
-            state.assignments[key] = assignment;
-            await this.writeState(state);
-            return {
-                accountId: selected.accountId,
-                assignment: { ...assignment },
-                created: !current,
-                migrated: Boolean(current && current.accountId !== selected.accountId),
-            };
-        }
-        finally {
-            await lock.release();
-        }
-    }
-    async clear(sessionId) {
-        if (!sessionId)
-            return;
-        const key = sessionKey(sessionId);
-        const lock = await this.acquireLock();
-        try {
-            const state = await this.readState();
-            if (!(key in state.assignments))
-                return;
-            delete state.assignments[key];
-            await this.writeState(state);
-        }
-        finally {
-            await lock.release();
-        }
-    }
-}