@cortexkit/opencode-openai-auth 0.11.1 → 1.0.1

package/src/tui-compiled/runtime/shared/8a18abe4fa2977c8-menu.js

@@ -0,0 +1,300 @@
+// One slash command per plugin: the menu a plugin creates once and serves to
+// every invocation. It keeps no per-invocation state; each `open` and `apply`
+// builds its sections afresh from the store and gets its own copy of the
+// caller's context.
+import { createLogger } from "./cc9e0702a752cea7-index.js";
+import { builtinSections, } from "./754d6017f8e419cf-builtins.js";
+import { applyResult, confirmationOf, createTextRedactor, dialogPayload, projectFailure, } from "./94820e324f2b4c09-seam.js";
+const BUILTIN_IDS = new Set([
+    'accounts',
+    'quota',
+    'routing',
+    'limits',
+    'cache',
+    'diagnostics',
+]);
+const STORE_SLOTS = [
+    'accounts',
+    'quota',
+    'routing',
+    'limits',
+];
+/**
+ * A private copy of the caller's context, taken before the first await. Work
+ * an invocation leaves running reports through this copy, so a host that
+ * reuses and rebinds one context object for the next session cannot pull an
+ * earlier invocation's feedback over to it.
+ */
+function ownInvocation(invocation, redact) {
+    const { sessionId } = invocation;
+    const notify = invocation.notify.bind(invocation);
+    // A notification leaves the process just as a payload does, so its text
+    // goes through the same redactor.
+    return Object.freeze({
+        ...(sessionId !== undefined ? { sessionId } : {}),
+        notify: (message, kind) => kind === undefined
+            ? notify(redact(String(message)))
+            : notify(redact(String(message)), kind),
+    });
+}
+function coerceOne(knob, raw) {
+    switch (knob.kind) {
+        case 'choice': {
+            const value = raw ?? knob.value;
+            if (typeof value === 'string' &&
+                knob.choices.some((choice) => choice.value === value))
+                return { value };
+            return { problem: `Choose one of the options for ${knob.label}.` };
+        }
+        case 'toggle': {
+            const value = raw ?? knob.value;
+            return typeof value === 'boolean'
+                ? { value }
+                : { problem: `${knob.label} must be on or off.` };
+        }
+        case 'number': {
+            const value = raw === undefined ? (knob.value ?? null) : raw;
+            if (value === null || value === '') {
+                return knob.required
+                    ? { problem: `${knob.label} needs a number.` }
+                    : { value: null };
+            }
+            const number = typeof value === 'number' ? value : Number(value);
+            if (typeof value === 'boolean' || !Number.isFinite(number))
+                return { problem: `${knob.label} needs a number.` };
+            if (knob.min !== undefined && number < knob.min)
+                return { problem: `${knob.label} must be at least ${knob.min}.` };
+            if (knob.max !== undefined && number > knob.max)
+                return { problem: `${knob.label} must be at most ${knob.max}.` };
+            return { value: number };
+        }
+        case 'text': {
+            const value = raw === undefined ? (knob.value ?? null) : raw;
+            if (value === null || value === '')
+                return knob.required
+                    ? { problem: `${knob.label} cannot be empty.` }
+                    : { value: null };
+            return typeof value === 'string'
+                ? { value }
+                : { problem: `${knob.label} must be text.` };
+        }
+    }
+}
+/** The action's inputs, checked against its knobs; unknown names are ignored. */
+function coerceValues(knobs, raw) {
+    const values = {};
+    for (const knob of knobs) {
+        const given = raw && Object.hasOwn(raw, knob.id) ? raw[knob.id] : undefined;
+        const result = coerceOne(knob, given);
+        if ('problem' in result)
+            return result;
+        values[knob.id] = result.value;
+    }
+    return { values };
+}
+function findAction(sections, request) {
+    const section = sections.find((entry) => entry.id === request.sectionId);
+    if (!section)
+        return undefined;
+    const actions = request.itemId === undefined
+        ? section.content.actions
+        : section.content.items?.find((item) => item.id === request.itemId)
+            ?.actions;
+    return actions?.find((action) => action.id === request.actionId);
+}
+export function createCommandMenu(options) {
+    const logger = options.logger ?? createLogger('commands');
+    const redact = createTextRedactor(options.redaction);
+    const seam = { logger, redact };
+    const now = options.now ?? Date.now;
+    const extras = options.extras ?? [];
+    const replaced = options.replace ?? {};
+    const builtSlots = STORE_SLOTS.filter((slot) => !replaced[slot]);
+    for (const slot of STORE_SLOTS) {
+        if (replaced[slot] && options[slot] !== undefined)
+            throw new Error(`the ${slot} section is replaced; its built-in options cannot also be given`);
+    }
+    const store = options.store;
+    if (builtSlots.length > 0 && !store)
+        throw new Error(`a store is required for the built-in ${builtSlots.join(', ')} section${builtSlots.length > 1 ? 's' : ''}`);
+    const seen = new Set();
+    for (const extra of extras) {
+        if (BUILTIN_IDS.has(extra.id) || seen.has(extra.id))
+            throw new Error(`extra section id ${extra.id} is taken`);
+        seen.add(extra.id);
+    }
+    async function plugin(id, slot, section, invocation) {
+        try {
+            return {
+                id,
+                slot,
+                title: section.title,
+                content: await section.build(invocation),
+            };
+        }
+        catch (error) {
+            // One broken plugin section must not take the whole menu down.
+            logger.warn('command menu section failed to build', {
+                command: options.command,
+                section: id,
+                error: redact(error instanceof Error ? error.message : String(error)),
+            });
+            return {
+                id,
+                slot,
+                title: section.title,
+                content: { lines: ['This section could not be loaded.'] },
+            };
+        }
+    }
+    /** Every section, in the fixed slot order. */
+    async function sections(invocation) {
+        // Built-in sections read the store once; a fully replaced menu never
+        // touches it.
+        const built = store && builtSlots.length > 0
+            ? await builtinSections({
+                store,
+                now,
+                ...(options.extraLocks ? { extraLocks: options.extraLocks } : {}),
+                ...(options.accounts ? { accounts: options.accounts } : {}),
+                ...(options.quota ? { quota: options.quota } : {}),
+                ...(options.routing ? { routing: options.routing } : {}),
+                ...(options.limits ? { limits: options.limits } : {}),
+            })
+            : [];
+        const out = [];
+        for (const slot of STORE_SLOTS) {
+            const replacement = replaced[slot];
+            if (replacement)
+                out.push(await plugin(slot, slot, replacement, invocation));
+            else {
+                const section = built.find((entry) => entry.slot === slot);
+                if (section)
+                    out.push(section);
+            }
+        }
+        if (options.cache)
+            out.push(await plugin('cache', 'cache', options.cache, invocation));
+        if (options.diagnostics)
+            out.push(await plugin('diagnostics', 'diagnostics', options.diagnostics, invocation));
+        for (const extra of extras)
+            out.push(await plugin(extra.id, 'extra', extra, invocation));
+        return out;
+    }
+    return {
+        command: options.command,
+        async open(invocation) {
+            const own = ownInvocation(invocation, redact);
+            return dialogPayload(options.command, options.title, await sections(own), seam);
+        },
+        async apply(request, invocation) {
+            const own = ownInvocation(invocation, redact);
+            const finish = async (outcome) => applyResult(options.command, options.title, await sections(own), outcome, seam);
+            const action = request.command === options.command
+                ? findAction(await sections(own), request)
+                : undefined;
+            if (!action)
+                return finish({
+                    ok: false,
+                    code: 'unavailable',
+                    text: 'That action is no longer available.',
+                });
+            const confirmation = confirmationOf(action);
+            if (confirmation && request.confirmed !== true)
+                return finish({
+                    ok: false,
+                    code: 'needs-confirmation',
+                    text: confirmation.message,
+                    needsConfirmation: true,
+                });
+            const coerced = coerceValues(action.knobs ?? [], request.values);
+            if ('problem' in coerced)
+                return finish({
+                    ok: false,
+                    code: 'invalid-input',
+                    text: coerced.problem,
+                });
+            let outcome;
+            try {
+                const result = await action.run({
+                    values: coerced.values,
+                    ...(request.itemId !== undefined ? { itemId: request.itemId } : {}),
+                    invocation: own,
+                });
+                outcome =
+                    typeof result === 'string'
+                        ? { ok: true, text: result }
+                        : {
+                            ok: result.ok,
+                            text: result.text,
+                            ...(result.ok ? {} : { code: result.code ?? 'refused' }),
+                        };
+            }
+            catch (error) {
+                // The raw text goes only to the log (redacted); the user sees the
+                // projected code and message, never the exception's own words.
+                const failure = projectFailure(error);
+                logger.warn('command menu action failed', {
+                    command: options.command,
+                    section: request.sectionId,
+                    action: request.actionId,
+                    code: failure.code,
+                    error: redact(error instanceof Error ? error.message : String(error)),
+                });
+                outcome = { ok: false, ...failure };
+            }
+            return finish(outcome);
+        },
+    };
+}
+function isKnobValue(value) {
+    return (value === null ||
+        typeof value === 'string' ||
+        typeof value === 'boolean' ||
+        (typeof value === 'number' && Number.isFinite(value)));
+}
+/**
+ * Checks an apply request that arrived over the loopback RPC; undefined when
+ * it is not one. Only the request's own fields are kept.
+ */
+export function parseApplyRequest(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const raw = value;
+    if (typeof raw.command !== 'string' ||
+        typeof raw.sectionId !== 'string' ||
+        typeof raw.actionId !== 'string')
+        return undefined;
+    if (raw.itemId !== undefined && typeof raw.itemId !== 'string')
+        return undefined;
+    if (raw.sessionId !== undefined && typeof raw.sessionId !== 'string')
+        return undefined;
+    if (raw.confirmed !== undefined && typeof raw.confirmed !== 'boolean')
+        return undefined;
+    const values = {};
+    if (raw.values !== undefined) {
+        if (raw.values === null ||
+            typeof raw.values !== 'object' ||
+            Array.isArray(raw.values))
+            return undefined;
+        for (const [name, entry] of Object.entries(raw.values)) {
+            if (!isKnobValue(entry))
+                return undefined;
+            Object.defineProperty(values, name, {
+                value: entry,
+                enumerable: true,
+                writable: true,
+                configurable: true,
+            });
+        }
+    }
+    return {
+        command: raw.command,
+        sectionId: raw.sectionId,
+        actionId: raw.actionId,
+        ...(typeof raw.itemId === 'string' ? { itemId: raw.itemId } : {}),
+        ...(raw.values !== undefined ? { values } : {}),
+        ...(raw.confirmed === true ? { confirmed: true } : {}),
+        ...(typeof raw.sessionId === 'string' ? { sessionId: raw.sessionId } : {}),
+    };
+}

package/src/tui-compiled/runtime/shared/901e149c5a0dbbff-sticky.js

@@ -0,0 +1,339 @@
+// `sticky-balanced` routing: openai-auth's quota-weighted session placement
+// and pin-break classification, judged over the quota projection rather than
+// openai-auth's fixed primary/secondary snapshot.
+import { budgetExhaustedResetAt, projectQuota, } from "./39c3cb05738fcf6d-projection.js";
+import { admit, } from "./45bf5343bbbf9add-admission.js";
+import { isPinValid } from "./c6b176708c446d6d-pins.js";
+export const QUOTA_STALENESS_MS = 15 * 60_000;
+export const MIN_RESET_HOURS = 1 / 60;
+export const MIN_WEIGHT = 1e-6;
+/** The projection's time, else the caller's cache-entry time. */
+export function snapshotCheckedAt(quota, entryCheckedAt) {
+    for (const checkedAt of [quota?.checkedAt, entryCheckedAt]) {
+        if (typeof checkedAt === 'number' && Number.isFinite(checkedAt)) {
+            return checkedAt;
+        }
+    }
+    return undefined;
+}
+/**
+ * The status rule used when the adapter supplies none, carried from
+ * openai-auth: 401 and 403 are permanent; no response, 0, a non-finite
+ * status, 429 and 5xx are transient; anything else leaves the row healthy.
+ * A provider whose 403 can mean an organisation or model policy rather than
+ * a dead account supplies its own classifier and can fall back to this one
+ * for the statuses it does not single out.
+ */
+export function defaultStickyStatusClass(status) {
+    if (status === 401 || status === 403)
+        return 'permanent';
+    if (status === undefined ||
+        status === 0 ||
+        !Number.isFinite(status) ||
+        (status >= 500 && status <= 599) ||
+        status === 429) {
+        return 'transient';
+    }
+    return 'healthy';
+}
+function windowReadings(quota) {
+    // Every reading is an independent constraint, so all of them are judged:
+    // a third window (for example a short window beside two weekly ones) can
+    // be the one that is nearly spent. Longest known window first, unknown
+    // lengths last, as openai-auth sorts, so a break decision with several
+    // spent windows names the longest. Tombstones and absence records carry no
+    // capacity figure and are left out.
+    return quota.limits
+        .filter((limit) => limit.kind === 'reading')
+        .sort((left, right) => {
+        const leftKnown = left.windowMinutes !== undefined;
+        const rightKnown = right.windowMinutes !== undefined;
+        if (leftKnown !== rightKnown)
+            return leftKnown ? -1 : 1;
+        if (leftKnown && rightKnown) {
+            return (right.windowMinutes ?? 0) - (left.windowMinutes ?? 0);
+        }
+        return 0;
+    });
+}
+/** Classifies whether a pinned session should leave its row after a failure. */
+export function decideStickyBreak(input) {
+    const statusClass = (input.classifyStatus ?? defaultStickyStatusClass)(input.status);
+    if (statusClass === 'permanent') {
+        return { action: 'migrate', reason: 'permanent' };
+    }
+    if (!input.quota)
+        return { action: 'retain', reason: 'unknown' };
+    const checkedAt = snapshotCheckedAt(input.quota, input.quotaCheckedAt);
+    if (checkedAt === undefined ||
+        !Number.isFinite(checkedAt) ||
+        input.now - checkedAt > QUOTA_STALENESS_MS) {
+        return { action: 'retain', reason: 'stale' };
+    }
+    // After the stale check, so a stale snapshot never judges the account on a
+    // reading the killswitch would consider below its floor.
+    if (input.killswitchPasses === false) {
+        return { action: 'migrate', reason: 'killswitch' };
+    }
+    for (const limit of windowReadings(input.quota)) {
+        const remaining = limit.remainingPercent;
+        if (typeof remaining === 'number' &&
+            Number.isFinite(remaining) &&
+            remaining <= 0) {
+            return {
+                action: 'migrate',
+                reason: 'exhausted',
+                window: { scope: limit.scope, label: limit.label },
+                ...(typeof limit.resetsAt === 'string'
+                    ? { resetsAt: limit.resetsAt }
+                    : {}),
+            };
+        }
+    }
+    // A reached credit budget is exhaustion on its own axis, judged by the same
+    // signal admission uses so the two never disagree on what "spent" means.
+    const budgetReset = budgetExhaustedResetAt(input.quota, input.now);
+    if (budgetReset) {
+        return {
+            action: 'migrate',
+            reason: 'exhausted',
+            resetsAt: budgetReset.resetsAt,
+        };
+    }
+    return { action: 'retain', reason: statusClass };
+}
+export function sustainableWindowWeight(window, reservePercent, now) {
+    const spendable = Math.max(0, window.remainingPercent - reservePercent);
+    if (spendable <= 0)
+        return 0;
+    if (!window.resetsAt)
+        return spendable;
+    const resetMs = Date.parse(window.resetsAt);
+    // A lapsed reset cannot yield a spend rate: the divisor would clamp to
+    // MIN_RESET_HOURS and inflate the weight about sixty-fold on stale
+    // information, so the un-rate-adjusted spendable capacity is used instead.
+    if (!Number.isFinite(resetMs) || resetMs <= now)
+        return spendable;
+    const hours = Math.max((resetMs - now) / 3_600_000, MIN_RESET_HOURS);
+    return spendable / hours;
+}
+function compareAccountIds(left, right) {
+    if (left < right)
+        return -1;
+    if (left > right)
+        return 1;
+    return 0;
+}
+function candidateWeight(candidate, now) {
+    if (!candidate.quota)
+        return undefined;
+    const quotaCheckedAt = snapshotCheckedAt(candidate.quota, candidate.quotaCheckedAt);
+    if (quotaCheckedAt === undefined ||
+        now - quotaCheckedAt > QUOTA_STALENESS_MS) {
+        return undefined;
+    }
+    // Missing reserve data must leave a window usable rather than silently
+    // excluding its account.
+    // The account is as constrained as its tightest window, whichever it is.
+    const weights = windowReadings(candidate.quota).map((limit) => sustainableWindowWeight({
+        remainingPercent: limit.remainingPercent ?? Number.NaN,
+        ...(limit.resetsAt === undefined ? {} : { resetsAt: limit.resetsAt }),
+    }, candidate.reservePercent[limit.label] ?? 0, now));
+    // The credit budget is a third pressure axis on its own reset clock. It has
+    // no configured reserve, and a malformed reading is ignored rather than
+    // allowed to zero the account's weight.
+    const budget = candidate.quota.budget;
+    if (budget &&
+        typeof budget.remainingPercent === 'number' &&
+        Number.isFinite(budget.remainingPercent)) {
+        weights.push(sustainableWindowWeight({
+            remainingPercent: budget.remainingPercent,
+            ...(budget.resetsAt === undefined
+                ? {}
+                : { resetsAt: budget.resetsAt }),
+        }, 0, now));
+    }
+    const weight = weights.length > 0 ? Math.min(...weights) : 0;
+    return weight > 0 ? { candidate, quotaCheckedAt, weight } : undefined;
+}
+/**
+ * Places a session: the lowest projected pressure among candidates with a
+ * fresh positive weight, else (`mode-fallback`) the first candidate in
+ * configured order, preferring one with an applicable reset credit.
+ */
+export function selectStickyCandidate(input) {
+    // A candidate killed by the killswitch is excluded from BOTH weighted
+    // placement and the fallback branch, which must never become a way to
+    // spend on a killed account.
+    const eligibleCandidates = input.candidates.filter((candidate) => candidate.killswitchPasses !== false);
+    if (input.candidates.length === 0) {
+        throw new Error('Cannot select a sticky candidate: input.candidates is empty');
+    }
+    if (eligibleCandidates.length === 0)
+        return undefined;
+    const weighted = eligibleCandidates
+        .map((candidate) => candidateWeight(candidate, input.now))
+        .filter((candidate) => candidate !== undefined);
+    if (weighted.length > 0) {
+        weighted.sort((left, right) => {
+            // MIN_WEIGHT only guards the division; every weight here is positive.
+            const leftScore = ((input.pendingBytes.get(left.candidate.accountId) ?? 0) +
+                input.requestBytes) /
+                Math.max(left.weight, MIN_WEIGHT);
+            const rightScore = ((input.pendingBytes.get(right.candidate.accountId) ?? 0) +
+                input.requestBytes) /
+                Math.max(right.weight, MIN_WEIGHT);
+            return (leftScore - rightScore ||
+                left.candidate.configuredOrder - right.candidate.configuredOrder ||
+                compareAccountIds(left.candidate.accountId, right.candidate.accountId));
+        });
+        const selected = weighted[0];
+        if (selected) {
+            return {
+                accountId: selected.candidate.accountId,
+                quotaCheckedAt: selected.quotaCheckedAt,
+                source: 'weighted',
+            };
+        }
+    }
+    input.onEmptyWeightedSet?.();
+    const fallback = [...eligibleCandidates].sort((left, right) => {
+        const leftHasCredits = (left.resetCreditsApplicable ?? 0) > 0 ? 1 : 0;
+        const rightHasCredits = (right.resetCreditsApplicable ?? 0) > 0 ? 1 : 0;
+        return (rightHasCredits - leftHasCredits ||
+            left.configuredOrder - right.configuredOrder ||
+            compareAccountIds(left.accountId, right.accountId));
+    })[0];
+    if (!fallback) {
+        throw new Error('Cannot select a sticky candidate: input.candidates is empty');
+    }
+    return {
+        accountId: fallback.accountId,
+        quotaCheckedAt: snapshotCheckedAt(fallback.quota, fallback.quotaCheckedAt),
+        source: 'mode-fallback',
+    };
+}
+/**
+ * Routes one request in `sticky-balanced` mode. A valid pin whose row is
+ * admitted, not excluded and not killed is dispatched as is. Otherwise
+ * selection runs over the non-excluded rows; each selected row admission
+ * refused is removed and selection re-runs, so the loop ends either on an
+ * admitted row or with no admissible account.
+ */
+export function routeSticky(input) {
+    const admission = admit(input);
+    const admitted = new Map(admission.admitted.map((row) => [row.id, row]));
+    const refusals = new Map(admission.refused.map((r) => [r.id, r]));
+    const excluded = new Set(admission.excluded.map((row) => row.id));
+    const validIds = new Set(input.rows.map((row) => row.id));
+    const pinValid = input.pin !== undefined &&
+        isPinValid(input.pin, validIds, input.identities?.get(input.pin.accountId));
+    if (pinValid && input.pin) {
+        const pinned = admitted.get(input.pin.accountId);
+        if (pinned && input.killswitch?.get(pinned.id) !== false) {
+            return {
+                outcome: 'dispatch',
+                accountId: pinned.id,
+                source: 'pin',
+                ...(pinned.projection?.checkedAt === undefined
+                    ? {}
+                    : { quotaCheckedAt: pinned.projection.checkedAt }),
+                pin: { action: 'retain' },
+                refusedSelections: [],
+                admission,
+            };
+        }
+    }
+    // A spent window with a future reset, a spent credit budget and a killswitch
+    // verdict all say the pinned row will not serve until some known later time,
+    // so the pin may move. A row refused for want of a usable reading, or
+    // excluded by a short rate-limit mark or refresh backoff, may serve again on
+    // the next reading, so its pin stays.
+    const pinRefusal = input.pin ? refusals.get(input.pin.accountId) : undefined;
+    const pinMoves = pinValid &&
+        input.pin !== undefined &&
+        input.refusedPinPolicy === 'move-on-confirmed-exhaustion' &&
+        (input.killswitch?.get(input.pin.accountId) === false ||
+            pinRefusal?.reason === 'exhausted' ||
+            pinRefusal?.reason === 'budget-spent');
+    const reserveFor = (row) => {
+        const perRow = typeof input.rowReservePercent === 'function'
+            ? input.rowReservePercent(row)
+            : input.rowReservePercent?.get(row.id);
+        return perRow ?? input.reservePercent ?? {};
+    };
+    const scope = input.scope;
+    let candidates = input.rows
+        .map((row, configuredOrder) => ({ row, configuredOrder }))
+        .filter(({ row }) => !excluded.has(row.id))
+        .map(({ row, configuredOrder }) => {
+        const killswitchPasses = input.killswitch?.get(row.id);
+        const credits = input.resetCreditsApplicable?.get(row.id);
+        return {
+            accountId: row.id,
+            quota: row.kind === 'api-key'
+                ? undefined
+                : (admitted.get(row.id)?.projection ??
+                    projectQuota(row.quota, scope)),
+            reservePercent: reserveFor(row),
+            configuredOrder,
+            ...(credits === undefined ? {} : { resetCreditsApplicable: credits }),
+            ...(killswitchPasses === undefined ? {} : { killswitchPasses }),
+        };
+    });
+    const refusedSelections = [];
+    const unplaced = pinValid
+        ? { action: 'retain' }
+        : input.pin
+            ? { action: 'clear' }
+            : { action: 'none' };
+    while (candidates.length > 0) {
+        const selection = selectStickyCandidate({
+            candidates,
+            pendingBytes: input.pendingBytes ?? new Map(),
+            requestBytes: input.requestBytes,
+            now: input.now,
+            ...(input.onEmptyWeightedSet
+                ? { onEmptyWeightedSet: input.onEmptyWeightedSet }
+                : {}),
+        });
+        if (!selection)
+            break;
+        const refusal = refusals.get(selection.accountId);
+        if (refusal) {
+            refusedSelections.push(refusal);
+            candidates = candidates.filter((candidate) => candidate.accountId !== selection.accountId);
+            continue;
+        }
+        const identity = input.identities?.get(selection.accountId);
+        return {
+            outcome: 'dispatch',
+            accountId: selection.accountId,
+            source: selection.source,
+            ...(selection.quotaCheckedAt === undefined
+                ? {}
+                : { quotaCheckedAt: selection.quotaCheckedAt }),
+            pin: pinValid && !pinMoves
+                ? { action: 'retain' }
+                : {
+                    action: 'assign',
+                    pin: {
+                        accountId: selection.accountId,
+                        inputBytes: input.requestBytes,
+                        ...(identity === undefined ? {} : { wireIdentity: identity }),
+                        ...(selection.quotaCheckedAt === undefined
+                            ? {}
+                            : { quotaCheckedAt: selection.quotaCheckedAt }),
+                    },
+                },
+            refusedSelections,
+            admission,
+        };
+    }
+    return {
+        outcome: 'no-admissible-account',
+        pin: unplaced,
+        refusedSelections,
+        admission,
+    };
+}