@cortexkit/opencode-openai-auth 0.11.1 → 1.0.0

package/src/tui-compiled/raw/shared/4f36d333d081d040-merge.js

@@ -0,0 +1,162 @@
+// Merging one observation into a stored quota map.
+//
+// One freshness rule applies everywhere: an observation applies to a key when
+// it is not older than what the key holds, so an equal time applies and the
+// observation applied last wins, as openai-auth's `freshestWindow` does.
+//
+// An observation carries readings plus a coverage list: the (scope, label)
+// pairs it speaks for with authority. Every reading is implicitly covered. A
+// covered pair the observation carries no reading for is reported as having
+// no limit: an existing reading becomes a retirement tombstone, and a key with
+// no entry gets an absence record. A pair outside the coverage is never
+// touched, so a header-shaped partial observation (which covers only what it
+// carries) cannot erase a family limit or the budget.
+import { ALL_SCOPE, entryTime, isQuotaMap, limitKey, } from "./905bffc0220f43d0-map.js";
+/** Thrown by `mergeQuotaObservation` when either argument is malformed. */
+export class QuotaCodecError extends TypeError {
+    constructor(message) {
+        super(message);
+        this.name = 'QuotaCodecError';
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+function isScope(value) {
+    return value === undefined || (typeof value === 'string' && value !== '');
+}
+function isLabel(value) {
+    return typeof value === 'string' && value !== '';
+}
+function optionalFinite(record, key) {
+    return record[key] === undefined || isFiniteNumber(record[key]);
+}
+function optionalString(record, key) {
+    return record[key] === undefined || typeof record[key] === 'string';
+}
+function isObservedReading(value) {
+    return (isRecord(value) &&
+        isScope(value.scope) &&
+        isLabel(value.label) &&
+        isFiniteNumber(value.usedPercent) &&
+        optionalString(value, 'resetsAt') &&
+        (value.windowMinutes === undefined ||
+            (isFiniteNumber(value.windowMinutes) && value.windowMinutes > 0)));
+}
+function isObservedPair(value) {
+    return isRecord(value) && isScope(value.scope) && isLabel(value.label);
+}
+function isObservedBudget(value) {
+    if (!isRecord(value))
+        return false;
+    if (value.kind === 'cleared')
+        return true;
+    return (value.kind === 'reading' &&
+        typeof value.reached === 'boolean' &&
+        optionalFinite(value, 'remainingPercent') &&
+        optionalFinite(value, 'usedPercent') &&
+        optionalString(value, 'resetsAt') &&
+        optionalFinite(value, 'limit') &&
+        optionalFinite(value, 'used') &&
+        optionalFinite(value, 'remaining') &&
+        optionalString(value, 'unit'));
+}
+/** True when `value` is a well-formed observation; a pair read twice is not. */
+export function isQuotaObservation(value) {
+    if (!isRecord(value) || !isFiniteNumber(value.checkedAt))
+        return false;
+    const readings = value.readings ?? [];
+    const coverage = value.coverage ?? [];
+    if (!Array.isArray(readings) || !Array.isArray(coverage))
+        return false;
+    const read = new Set();
+    for (const reading of readings) {
+        if (!isObservedReading(reading))
+            return false;
+        const key = limitKey(reading.scope ?? ALL_SCOPE, reading.label);
+        if (read.has(key))
+            return false;
+        read.add(key);
+    }
+    if (!coverage.every(isObservedPair))
+        return false;
+    return value.budget === undefined || isObservedBudget(value.budget);
+}
+function compareEntries(left, right) {
+    if (left.scope !== right.scope)
+        return left.scope < right.scope ? -1 : 1;
+    if (left.label !== right.label)
+        return left.label < right.label ? -1 : 1;
+    return 0;
+}
+function mergeBudget(stored, observed, checkedAt) {
+    if (observed === undefined)
+        return stored;
+    if (stored !== undefined && checkedAt < stored.checkedAt)
+        return stored;
+    return { ...observed, checkedAt };
+}
+/**
+ * Applies `observation` to `stored` (undefined for a row with no map yet) and
+ * returns the new map. Pure: neither argument is modified. Throws
+ * `QuotaCodecError` when either argument is malformed, so a store refuses the
+ * write rather than persisting a map it could not read back.
+ */
+export function mergeQuotaObservation(stored, observation) {
+    if (stored !== undefined && !isQuotaMap(stored)) {
+        throw new QuotaCodecError('stored quota map is malformed');
+    }
+    if (!isQuotaObservation(observation)) {
+        throw new QuotaCodecError('quota observation is malformed');
+    }
+    const base = stored ?? { limits: [] };
+    const at = observation.checkedAt;
+    const entries = new Map();
+    for (const entry of base.limits) {
+        entries.set(limitKey(entry.scope, entry.label), entry);
+    }
+    const applies = (key) => {
+        const existing = entries.get(key);
+        return existing === undefined || at >= entryTime(existing);
+    };
+    const carried = new Set();
+    for (const reading of observation.readings ?? []) {
+        const scope = reading.scope ?? ALL_SCOPE;
+        const key = limitKey(scope, reading.label);
+        carried.add(key);
+        if (!applies(key))
+            continue;
+        entries.set(key, {
+            scope,
+            label: reading.label,
+            kind: 'reading',
+            checkedAt: at,
+            usedPercent: reading.usedPercent,
+            ...(reading.resetsAt === undefined ? {} : { resetsAt: reading.resetsAt }),
+            ...(reading.windowMinutes === undefined
+                ? {}
+                : { windowMinutes: reading.windowMinutes }),
+        });
+    }
+    for (const pair of observation.coverage ?? []) {
+        const scope = pair.scope ?? ALL_SCOPE;
+        const key = limitKey(scope, pair.label);
+        if (carried.has(key) || !applies(key))
+            continue;
+        const existing = entries.get(key);
+        entries.set(key, existing === undefined || existing.kind === 'absent'
+            ? { scope, label: pair.label, kind: 'absent', checkedAt: at }
+            : { scope, label: pair.label, kind: 'retired', retiredAt: at });
+    }
+    // Keys this module does not recognise are carried over untouched.
+    const { limits: _limits, budget: _budget, ...unknownKeys } = base;
+    const budget = mergeBudget(base.budget, observation.budget, at);
+    return {
+        ...unknownKeys,
+        limits: [...entries.values()].sort(compareEntries),
+        ...(budget === undefined ? {} : { budget }),
+    };
+}

package/src/tui-compiled/raw/shared/54eba94fd64c8c3c-index.js

@@ -0,0 +1,7 @@
+export { PoolOperationError, PoolReentryError } from "./04a6357627de5ed0-errors.js";
+export { countUnknownIdentityRows, DUPLICATE_IDENTITY_REASON, } from "./75bd8c3bd63b315f-identity.js";
+export { openPoolStore } from "./c852a15cfe489d12-pool.js";
+export { DECLINE_TRANSITION } from "./97484d9bb98c705b-provider-state.js";
+export { POOL_LOCK_DEFAULTS } from "./43fc9e6b994519c7-refresh-lock.js";
+export { fingerprintOf, LEGACY_STORE_VERSION, POOL_KEY, POOL_ROWS_KEY, POOL_SCHEMA_VERSION, PROVIDER_STATE_KEY, REFRESH_STAMP_TOLERANCE_MS, rowLockKey, } from "./cd94316a888b0a8e-schema.js";
+export { POOL_OWNED_KEYS } from "./836fc615de6afbd9-settings.js";

package/src/tui-compiled/raw/shared/7211cfec06a298bc-atomic-write.js

@@ -0,0 +1,80 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, open, rename, rm } from "node:fs/promises";
+import { dirname } from "node:path";
+/** Internal classification of fsync failures, including a failure after rename. */
+export class AtomicSyncError extends Error {
+    constructor(cause) {
+        super('file or directory sync failed', { cause });
+        this.name = 'AtomicSyncError';
+    }
+}
+export async function writeJsonAtomic(path, value, options = {}) {
+    await writeJsonAtomicTracked(path, value, options);
+}
+/**
+ * Notify internal callers at the rename. The store records committed writes
+ * and removed ids here, because a later directory sync cannot undo the rename.
+ */
+export async function writeJsonAtomicTracked(path, value, options, onRenamed) {
+    await mkdir(dirname(path), { recursive: true });
+    const tempPath = `${path}.${(options.stageName ?? randomUUID)()}.tmp`;
+    let handle;
+    let created = false;
+    try {
+        handle = await open(tempPath, 'wx', 0o600);
+        created = true;
+        await handle.writeFile(options.serialize
+            ? options.serialize(value)
+            : `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+        await handle.chmod(0o600);
+        if (options.durable) {
+            try {
+                await handle.sync();
+            }
+            catch (cause) {
+                throw new AtomicSyncError(cause);
+            }
+        }
+        await handle.close();
+        handle = undefined;
+        await options.beforeRename?.();
+        await rename(tempPath, path);
+        created = false;
+        onRenamed?.();
+        if (options.durable) {
+            const directory = await open(dirname(path), 'r');
+            try {
+                await directory.sync();
+            }
+            catch (cause) {
+                throw new AtomicSyncError(cause);
+            }
+            finally {
+                await directory.close();
+            }
+        }
+    }
+    finally {
+        await handle?.close().catch(() => { });
+        // A failed write can leave partial bytes, but a collision is not ours to remove.
+        if (created)
+            await rm(tempPath, { force: true }).catch(() => { });
+    }
+}
+/** Make an already renamed file and its directory durable without rewriting bytes. */
+export async function syncJsonFile(path) {
+    const file = await open(path, 'r');
+    try {
+        await file.sync();
+    }
+    finally {
+        await file.close();
+    }
+    const directory = await open(dirname(path), 'r');
+    try {
+        await directory.sync();
+    }
+    finally {
+        await directory.close();
+    }
+}