@kunkun.sh/kuota 0.0.0-stage → 0.1.0

package/dist/src-C48Ew_L9.mjs

@@ -0,0 +1,707 @@
+import { a as makeObservation, o as makeUnavailableSnapshot, s as normalizeWindow } from "./dist-CIjerpSd.mjs";
+import { Effect } from "effect";
+import { spawn } from "node:child_process";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
+import { delimiter, join } from "node:path";
+// ../providers/src/codex/protocol.ts
+function asRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+/** Parses only the non-sensitive subset of the Codex app-server v2 quota response. */
+function parseCodexRateLimits(raw, fetchedAt = /* @__PURE__ */ new Date()) {
+	const response = asRecord(raw);
+	const limits = asRecord(response?.rateLimits);
+	const common = {
+		provider: "codex",
+		source: "codex-app-server",
+		fetchedAt: fetchedAt.toISOString()
+	};
+	if (!limits) return {
+		...common,
+		status: "unavailable",
+		windows: [],
+		errorCode: "NO_RATE_LIMITS"
+	};
+	let malformed = false;
+	const windows = [];
+	for (const windowId of ["primary", "secondary"]) {
+		const window = asRecord(limits[windowId]);
+		if (!window) continue;
+		const usedPercent = window.usedPercent;
+		if (typeof usedPercent !== "number" || !Number.isFinite(usedPercent) || usedPercent < 0 || usedPercent > 100) malformed = true;
+		const reset = window.resetsAt;
+		const resetAt = typeof reset === "number" && Number.isFinite(reset) && reset >= 0 ? (/* @__PURE__ */ new Date(reset * 1e3)).toISOString() : null;
+		windows.push(normalizeWindow({
+			windowId,
+			usedPercent,
+			resetAt
+		}));
+	}
+	const blocked = response?.ordinaryUsageAllowed === false;
+	return {
+		...common,
+		status: windows.length === 0 ? "unavailable" : malformed || blocked ? "partial" : "ok",
+		windows,
+		errorCode: windows.length === 0 ? "NO_WINDOWS" : blocked ? "ORDINARY_USAGE_BLOCKED" : malformed ? "INVALID_WINDOW" : null
+	};
+}
+// ../providers/src/codex/transport.ts
+/** Fixed, safe error messages: never forward stderr or a raw RPC response. */
+var CodexTransportError = class extends Error {
+	code;
+	constructor(code) {
+		super({
+			BINARY_NOT_FOUND: "Codex executable was not found",
+			TIMEOUT: "Codex app-server did not respond in time",
+			PROTOCOL_ERROR: "Codex app-server protocol failed"
+		}[code]);
+		this.code = code;
+		this.name = "CodexTransportError";
+	}
+};
+/** One bounded RPC session. Never spawns a bare Codex TUI and never prints raw output. */
+function requestCodexRateLimits(options = {}) {
+	const binary = options.binary ?? "codex";
+	const args = options.args ?? ["app-server"];
+	const timeoutMs = Math.max(100, Math.min(options.timeoutMs ?? 15e3, 6e4));
+	return new Promise((resolve, reject) => {
+		const child = spawn(binary, [...args], {
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			],
+			shell: false
+		});
+		let settled = false;
+		let phase = "initializing";
+		let buffer = "";
+		const finish = (error, result) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timeout);
+			child.stdin.end();
+			if (!child.killed && child.exitCode === null) child.kill("SIGTERM");
+			if (error) reject(error);
+			else resolve(result);
+		};
+		const timeout = setTimeout(() => finish(new CodexTransportError("TIMEOUT")), timeoutMs);
+		const send = (message) => {
+			if (settled) return;
+			try {
+				child.stdin.write(`${JSON.stringify(message)}\n`);
+			} catch {
+				finish(new CodexTransportError("PROTOCOL_ERROR"));
+			}
+		};
+		child.once("error", (error) => {
+			finish(new CodexTransportError(error.code === "ENOENT" ? "BINARY_NOT_FOUND" : "PROTOCOL_ERROR"));
+		});
+		child.once("exit", () => finish(new CodexTransportError("PROTOCOL_ERROR")));
+		child.stdin.on("error", () => finish(new CodexTransportError("PROTOCOL_ERROR")));
+		child.stderr.resume();
+		const onMessage = (value) => {
+			const msg = value !== null && typeof value === "object" ? value : null;
+			if (!msg || typeof msg.id !== "number") return;
+			if (phase === "initializing" && msg.id === 1) {
+				if (msg.error || !msg.result) return finish(new CodexTransportError("PROTOCOL_ERROR"));
+				phase = "reading";
+				send({ method: "initialized" });
+				send({
+					id: 2,
+					method: "account/rateLimits/read"
+				});
+			} else if (phase === "reading" && msg.id === 2) {
+				if (msg.error || !msg.result) return finish(new CodexTransportError("PROTOCOL_ERROR"));
+				finish(void 0, msg.result);
+			}
+		};
+		child.stdout.on("data", (chunk) => {
+			if (settled) return;
+			buffer += chunk.toString("utf8");
+			if (buffer.length > 2e6) return finish(new CodexTransportError("PROTOCOL_ERROR"));
+			while (!settled) {
+				const index = buffer.indexOf("\n");
+				if (index < 0) break;
+				const line = buffer.slice(0, index).trim();
+				buffer = buffer.slice(index + 1);
+				if (!line) continue;
+				try {
+					onMessage(JSON.parse(line));
+				} catch {
+					finish(new CodexTransportError("PROTOCOL_ERROR"));
+				}
+			}
+		});
+		send({
+			id: 1,
+			method: "initialize",
+			params: { clientInfo: {
+				name: "kuota",
+				version: "0.1.0"
+			} }
+		});
+	});
+}
+// ../providers/src/codex/index.ts
+function readCodex(options = {}) {
+	return Effect.promise(async () => {
+		try {
+			return parseCodexRateLimits(await requestCodexRateLimits(options));
+		} catch (error) {
+			const code = error instanceof CodexTransportError ? error.code : "UNKNOWN";
+			return makeUnavailableSnapshot("codex", code, code === "BINARY_NOT_FOUND" ? "unsupported" : "unavailable");
+		}
+	});
+}
+// ../providers/src/antigravity/index.ts
+function record$1(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function slug$1(value) {
+	return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40) || "quota";
+}
+function groupId(value) {
+	if (/^gemini models?$/i.test(value)) return "gemini";
+	if (/^claude and gpt(?: models?)?$/i.test(value)) return "claude-gpt";
+	return slug$1(value);
+}
+function validFraction(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1;
+}
+/** Parses agy >=1.1.11's structured `-p /usage --output-format json` response. */
+function parseAntigravityUsageReport(raw) {
+	const data = record$1(raw);
+	const command = record$1(data?.command);
+	const payload = record$1(command?.data);
+	if (data?.status !== "SUCCESS" || command?.name !== "usage" || !Array.isArray(payload?.groups)) throw new Error("INVALID_USAGE_REPORT");
+	const windows = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const group of payload.groups) {
+		const info = record$1(group);
+		if (!info || !Array.isArray(info.buckets)) continue;
+		const family = groupId(typeof info.name === "string" ? info.name : typeof info.display_name === "string" ? info.display_name : "quota");
+		for (const bucket of info.buckets) {
+			const value = record$1(bucket);
+			if (!value || value.disabled === true) continue;
+			const nested = record$1(value.remaining);
+			const remaining = value.remaining_fraction ?? nested?.remaining_fraction ?? (nested?.case === "remainingFraction" ? nested.value : void 0);
+			if (!validFraction(remaining)) continue;
+			const name = `${family}.${typeof value.window === "string" ? slug$1(value.window) : typeof value.id === "string" ? slug$1(value.id) : "quota"}`;
+			const windowId = seen.has(name) ? `${name}:${slug$1(String(value.id ?? value.bucket_id ?? "additional"))}` : name;
+			seen.add(windowId);
+			windows.push(normalizeWindow({
+				windowId,
+				usedPercent: Number(((1 - remaining) * 100).toFixed(2)),
+				resetAt: value.reset_time ?? value.resetTime
+			}));
+		}
+	}
+	if (windows.length === 0) throw new Error("NO_MEASURED_QUOTA");
+	return {
+		provider: "antigravity",
+		status: "ok",
+		fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		source: "agy-cli-print",
+		windows,
+		errorCode: null
+	};
+}
+/** Version strings with suffixes are intentionally rejected to avoid guessing support. */
+function parseAgyVersion(value) {
+	const match = /^(\d+)\.(\d+)\.(\d+)\s*$/.exec(value.trim());
+	if (!match) return false;
+	const major = Number(match[1]);
+	const minor = Number(match[2]);
+	const patch = Number(match[3]);
+	return major > 1 || major === 1 && (minor > 1 || minor === 1 && patch >= 11);
+}
+var AgyProbeError = class extends Error {
+	code;
+	constructor(code) {
+		super(code);
+		this.code = code;
+	}
+};
+/** Bound subprocess output and lifetime; never print raw stdout/stderr or OAuth URLs. */
+function execute(binary, args, options) {
+	return new Promise((resolve, reject) => {
+		const child = spawn(binary, args, {
+			cwd: options.cwd,
+			env: options.env,
+			detached: process.platform !== "win32",
+			windowsHide: true,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		const chunks = [];
+		let bytes = 0;
+		let stderr = "";
+		let settled = false;
+		const stop = () => {
+			if (child.pid && process.platform !== "win32") try {
+				process.kill(-child.pid, "SIGTERM");
+			} catch {}
+			else try {
+				child.kill("SIGTERM");
+			} catch {}
+		};
+		const finish = (error) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			stop();
+			if (error) reject(error);
+			else resolve(Buffer.concat(chunks).toString("utf8"));
+		};
+		const timer = setTimeout(() => finish(new AgyProbeError("TIMEOUT")), options.timeoutMs);
+		child.stdout?.on("data", (chunk) => {
+			bytes += chunk.length;
+			if (bytes > options.maxOutputBytes) finish(new AgyProbeError("OUTPUT_TOO_LARGE"));
+			else if (!settled) chunks.push(chunk);
+		});
+		child.stderr?.on("data", (chunk) => {
+			if (stderr.length < 4096) stderr += chunk.toString("utf8").slice(0, 4096 - stderr.length);
+		});
+		child.once("error", (error) => finish(new AgyProbeError(error.code === "ENOENT" ? "BINARY_NOT_FOUND" : "CLI_FAILED")));
+		child.once("close", (code) => {
+			if (code === 0) finish();
+			else if (/not logged in|authentication required|sign.?in|please visit/i.test(stderr)) finish(new AgyProbeError("AUTH_REQUIRED"));
+			else finish(new AgyProbeError("CLI_FAILED"));
+		});
+	});
+}
+/** No new account login. Existing agy credentials only, guarded from browser launch and auto-update. */
+function readAntigravity(options = {}) {
+	return Effect.promise(async () => {
+		const directory = await mkdtemp(join(tmpdir(), "kuota-agy-"));
+		try {
+			const script = "#!/bin/sh\nexit 1\n";
+			for (const name of [
+				"open",
+				"xdg-open",
+				"browser"
+			]) await writeFile(join(directory, name), script, { mode: 448 });
+			const env = { ...process.env };
+			delete env.ANTIGRAVITY_OAUTH_CREDENTIALS_JSON;
+			env.AGY_CLI_DISABLE_AUTO_UPDATE = "true";
+			env.PATH = `${directory}${delimiter}${process.env.PATH ?? ""}`;
+			env.BROWSER = join(directory, "browser");
+			const binary = options.binary ?? "agy";
+			const context = {
+				cwd: directory,
+				env
+			};
+			if (!parseAgyVersion(await execute(binary, ["--version"], {
+				...context,
+				timeoutMs: 3e3,
+				maxOutputBytes: 8192
+			}))) throw new AgyProbeError("UNSUPPORTED_VERSION");
+			const text = await execute(binary, [
+				"-p",
+				"/usage",
+				"--output-format",
+				"json",
+				"--print-timeout",
+				"90s"
+			], {
+				...context,
+				timeoutMs: options.timeoutMs ?? 2e4,
+				maxOutputBytes: options.maxOutputBytes ?? 1048576
+			});
+			try {
+				return parseAntigravityUsageReport(JSON.parse(text));
+			} catch {
+				throw new AgyProbeError("PROTOCOL_ERROR");
+			}
+		} catch (error) {
+			const code = error instanceof AgyProbeError ? error.code : "CLI_FAILED";
+			return makeUnavailableSnapshot("antigravity", code, code === "AUTH_REQUIRED" ? "unauthenticated" : "unavailable");
+		} finally {
+			await rm(directory, {
+				recursive: true,
+				force: true
+			});
+		}
+	});
+}
+// ../providers/src/claude/index.ts
+function record(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function validPercent(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 100;
+}
+function slug(value) {
+	return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 50);
+}
+/** Only a Claude subscription OAuth token works; MCP-only and API keys are not quota tokens. */
+function extractClaudeOAuthToken(raw, now = Date.now()) {
+	const oauth = record(record(raw)?.claudeAiOauth);
+	const token = oauth?.accessToken;
+	const expiresAt = oauth?.expiresAt;
+	if (typeof token !== "string" || !token.trim() || !validExpiry(expiresAt, now)) return null;
+	return token.trim();
+}
+function validExpiry(value, now) {
+	return typeof value === "number" && Number.isFinite(value) && value > now;
+}
+/** Claude API reports utilization (used percent), not remaining percent. */
+function parseClaudeOAuthUsage(raw) {
+	const payload = record(raw);
+	if (!payload) throw new Error("INVALID_CLAUDE_USAGE");
+	const windows = [];
+	const add = (windowId, value) => {
+		const data = record(value);
+		if (!validPercent(data?.utilization)) return;
+		windows.push(normalizeWindow({
+			windowId,
+			usedPercent: data.utilization,
+			resetAt: data.resets_at
+		}));
+	};
+	add("session.5h", payload.five_hour);
+	if (validPercent(record(payload.seven_day)?.utilization)) add("weekly.all", payload.seven_day);
+	else add("weekly.oauth-apps", payload.seven_day_oauth_apps);
+	add("weekly.sonnet", payload.seven_day_sonnet);
+	add("weekly.opus", payload.seven_day_opus);
+	for (const key of [
+		"seven_day_routines",
+		"seven_day_claude_routines",
+		"claude_routines",
+		"routines",
+		"seven_day_cowork",
+		"cowork"
+	]) if (validPercent(record(payload[key])?.utilization)) {
+		add("weekly.routines", payload[key]);
+		break;
+	}
+	if (Array.isArray(payload.limits)) {
+		const seen = /* @__PURE__ */ new Set();
+		for (const entry of payload.limits) {
+			const limit = record(entry);
+			const model = record(record(limit?.scope)?.model);
+			if (limit?.kind !== "weekly_scoped" || !validPercent(limit.percent)) continue;
+			const id = slug(typeof model?.display_name === "string" ? model.display_name : typeof model?.id === "string" ? model.id : "");
+			if (!id || id === "all-models") continue;
+			const windowId = `weekly.${id}`;
+			if (seen.has(windowId) || windows.some((w) => w.windowId === windowId)) continue;
+			seen.add(windowId);
+			windows.push(normalizeWindow({
+				windowId,
+				usedPercent: limit.percent,
+				resetAt: limit.resets_at
+			}));
+		}
+	}
+	return {
+		provider: "claude",
+		source: "claude-oauth-usage",
+		status: windows.length ? "ok" : "unavailable",
+		fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		windows,
+		errorCode: windows.length ? null : "NO_MEASURED_QUOTA"
+	};
+}
+const ENDPOINT = "https://api.anthropic.com/api/oauth/usage";
+const MAX_BODY = 1048576;
+/** Read at most 1 MiB, without placing raw HTTP error responses in logs or JSON output. */
+async function readBoundedResponse(response) {
+	if (!response.body) return "";
+	const reader = response.body.getReader();
+	const buffers = [];
+	let total = 0;
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			total += value.byteLength;
+			if (total > MAX_BODY) throw new Error("RESPONSE_TOO_LARGE");
+			buffers.push(value);
+		}
+		const joined = new Uint8Array(total);
+		let offset = 0;
+		for (const buffer of buffers) {
+			joined.set(buffer, offset);
+			offset += buffer.byteLength;
+		}
+		return new TextDecoder().decode(joined);
+	} finally {
+		reader.releaseLock();
+	}
+}
+async function resolveToken(options) {
+	if (options.token) return options.token.trim() || null;
+	const fromEnvironment = process.env.CLAUDE_CODE_OAUTH_TOKEN;
+	if (fromEnvironment?.trim()) return fromEnvironment.trim();
+	try {
+		const file = options.credentialsFile ?? join(homedir(), ".claude", ".credentials.json");
+		return extractClaudeOAuthToken(JSON.parse(await readFile(file, "utf8")));
+	} catch {
+		return null;
+	}
+}
+/** No Keychain UI access, credential refresh, browser sign-in or CLI session side effects. */
+function readClaude(options = {}) {
+	return Effect.promise(async () => {
+		const token = await resolveToken(options);
+		if (!token) return makeUnavailableSnapshot("claude", "AUTH_REQUIRED", "unauthenticated");
+		const controller = new AbortController();
+		const timer = setTimeout(() => controller.abort(), options.timeoutMs ?? 12e3);
+		try {
+			const request = (url, agent) => (options.fetchImpl ?? fetch)(url, {
+				method: "GET",
+				redirect: "error",
+				cache: "no-store",
+				headers: {
+					Authorization: `Bearer ${token}`,
+					Accept: "application/json",
+					"Content-Type": "application/json",
+					"anthropic-beta": "oauth-2025-04-20",
+					"User-Agent": agent
+				},
+				signal: controller.signal
+			});
+			let response = await request(`${ENDPOINT}?cedar_ember=1`, "claude-cli/2.1.0 (external, cli)");
+			if (response.status === 400 || response.status === 403) response = await request(ENDPOINT, "claude-code/2.1.0");
+			if (response.status === 401) return makeUnavailableSnapshot("claude", "AUTH_REQUIRED", "unauthenticated");
+			if (response.status === 429) return makeUnavailableSnapshot("claude", "RATE_LIMITED");
+			if (response.status !== 200) return makeUnavailableSnapshot("claude", "HTTP_ERROR");
+			const content = await readBoundedResponse(response);
+			try {
+				return parseClaudeOAuthUsage(JSON.parse(content));
+			} catch {
+				return makeUnavailableSnapshot("claude", "PROTOCOL_ERROR");
+			}
+		} catch (error) {
+			return makeUnavailableSnapshot("claude", controller.signal.aborted ? "TIMEOUT" : error instanceof Error && error.message === "RESPONSE_TOO_LARGE" ? "OUTPUT_TOO_LARGE" : "NETWORK_ERROR");
+		} finally {
+			clearTimeout(timer);
+		}
+	});
+}
+// ../providers/src/registry.ts
+const PROVIDER_METADATA = [
+	{
+		id: "codex",
+		label: "OpenAI Codex",
+		implemented: true,
+		source: "codex-app-server"
+	},
+	{
+		id: "claude",
+		label: "Claude Code",
+		implemented: true,
+		source: "claude-oauth-usage"
+	},
+	{
+		id: "antigravity",
+		label: "Google Antigravity",
+		implemented: true,
+		source: "agy-cli-print"
+	}
+];
+/** Static names are extensible to runtime manifests in the later plugin phase. */
+function isProviderId(value) {
+	return PROVIDER_METADATA.some((provider) => provider.id === value);
+}
+function builtInProviders() {
+	return [
+		{
+			id: "codex",
+			label: "OpenAI Codex",
+			read: () => readCodex()
+		},
+		{
+			id: "claude",
+			label: "Claude Code",
+			read: () => readClaude()
+		},
+		{
+			id: "antigravity",
+			label: "Google Antigravity",
+			read: () => readAntigravity()
+		}
+	];
+}
+/** One failed adapter never prevents other providers from reporting. */
+function readAll(ids, providers = builtInProviders()) {
+	const byId = new Map(providers.map((provider) => [provider.id, provider]));
+	return Effect.all(ids.map((id) => {
+		const provider = byId.get(id);
+		if (!provider) return Effect.succeed(makeUnavailableSnapshot(id, "NOT_REGISTERED", "unsupported"));
+		return provider.read().pipe(Effect.catchAllCause(() => Effect.succeed(makeUnavailableSnapshot(id, "PROVIDER_FAILED"))));
+	}), { concurrency: 3 });
+}
+// ../providers/src/service.ts
+const COMMON = {
+	errorRetryMs: 6e4,
+	authRetryMs: 3e5,
+	rateLimitCooldownMs: 9e5,
+	staleMaxAgeMs: 864e5
+};
+const DEFAULT_POLICIES = {
+	codex: {
+		...COMMON,
+		successTtlMs: 6e4
+	},
+	claude: {
+		...COMMON,
+		successTtlMs: 9e5
+	},
+	antigravity: {
+		...COMMON,
+		successTtlMs: 3e5
+	}
+};
+const emptySlot = (generation) => ({
+	lastGood: null,
+	lastFailure: null,
+	lastCheckedAtMs: 0,
+	nextAttemptAtMs: 0,
+	inflight: null,
+	generation
+});
+const isMeasurable = (s) => (s.status === "ok" || s.status === "partial") && s.windows.length > 0;
+/**
+* Process-local TTL cache with per-provider singleflight, failure cooldowns and honest
+* stale labelling. Only normalized snapshots are retained.
+*/
+function createQuotaService(options = {}) {
+	const now = options.now ?? Date.now;
+	const providers = new Map((options.providers ?? builtInProviders()).map((provider) => [provider.id, provider]));
+	const slots = /* @__PURE__ */ new Map();
+	const generations = /* @__PURE__ */ new Map();
+	const policyFor = (id) => ({
+		...DEFAULT_POLICIES[id],
+		...options.policies?.[id]
+	});
+	const slotFor = (id) => {
+		let slot = slots.get(id);
+		if (!slot) {
+			slot = emptySlot(generations.get(id) ?? 0);
+			slots.set(id, slot);
+		}
+		return slot;
+	};
+	const view = (id, freshProbe) => {
+		const slot = slots.get(id);
+		if (!slot) return null;
+		const t = now();
+		const policy = policyFor(id);
+		const good = slot.lastGood;
+		const goodMs = good ? Date.parse(good.fetchedAt) : NaN;
+		const goodUsable = good !== null && !(t - (Number.isFinite(goodMs) ? goodMs : slot.lastCheckedAtMs) > policy.staleMaxAgeMs);
+		const nextAttemptAtMs = slot.nextAttemptAtMs > t ? slot.nextAttemptAtMs : null;
+		if (good && goodUsable) {
+			const failed = slot.lastFailure;
+			return makeObservation({
+				snapshot: good,
+				freshness: failed ? "stale" : freshProbe ? "live" : "cached",
+				checkedAtMs: slot.lastCheckedAtMs,
+				nowMs: t,
+				nextAttemptAtMs,
+				latestErrorCode: failed?.errorCode ?? null
+			});
+		}
+		if (slot.lastFailure) return makeObservation({
+			snapshot: slot.lastFailure,
+			freshness: freshProbe ? "live" : "cached",
+			checkedAtMs: slot.lastCheckedAtMs,
+			nowMs: t,
+			nextAttemptAtMs,
+			latestErrorCode: slot.lastFailure.errorCode
+		});
+		return null;
+	};
+	const probe = (id, provider, slot) => {
+		const attemptAt = now();
+		const settled = Effect.runPromise(provider.read().pipe(Effect.catchAllCause(() => Effect.succeed({
+			...makeUnavailableSnapshot(id, "PROVIDER_FAILED"),
+			fetchedAt: new Date(attemptAt).toISOString()
+		})))).catch(() => ({
+			...makeUnavailableSnapshot(id, "PROVIDER_FAILED"),
+			fetchedAt: new Date(attemptAt).toISOString()
+		})).then((snapshot) => {
+			if (slots.get(id) !== slot || slot.generation !== (generations.get(id) ?? 0)) return;
+			const policy = policyFor(id);
+			const t = now();
+			slot.lastCheckedAtMs = attemptAt;
+			if (isMeasurable(snapshot)) {
+				slot.lastGood = snapshot;
+				slot.lastFailure = null;
+				slot.nextAttemptAtMs = 0;
+				return;
+			}
+			slot.lastFailure = snapshot;
+			if (snapshot.errorCode === "RATE_LIMITED") slot.nextAttemptAtMs = t + policy.rateLimitCooldownMs;
+			else if (snapshot.errorCode === "AUTH_REQUIRED" || snapshot.status === "unauthenticated") {
+				slot.lastGood = null;
+				slot.nextAttemptAtMs = t + policy.authRetryMs;
+			} else slot.nextAttemptAtMs = t + policy.errorRetryMs;
+		}).finally(() => {
+			if (slot.inflight === settled) slot.inflight = null;
+		});
+		slot.inflight = settled;
+		return settled;
+	};
+	const readOne = async (id, force) => {
+		const provider = providers.get(id);
+		if (!provider) {
+			const t = now();
+			return makeObservation({
+				snapshot: {
+					...makeUnavailableSnapshot(id, "NOT_REGISTERED", "unsupported"),
+					fetchedAt: new Date(t).toISOString()
+				},
+				freshness: "live",
+				checkedAtMs: t,
+				nowMs: t,
+				latestErrorCode: "NOT_REGISTERED"
+			});
+		}
+		const slot = slotFor(id);
+		if (slot.inflight) {
+			await slot.inflight;
+			return view(id, true) ?? await readOne(id, force);
+		}
+		const t = now();
+		const coolingDown = slot.nextAttemptAtMs > t;
+		const goodMs = slot.lastGood ? Date.parse(slot.lastGood.fetchedAt) : NaN;
+		const fresh = slot.lastGood !== null && slot.lastFailure === null && Number.isFinite(goodMs) && t - goodMs < policyFor(id).successTtlMs;
+		if (coolingDown || fresh && !force) {
+			const cached = view(id, false);
+			if (cached) return cached;
+		}
+		await probe(id, provider, slot);
+		const result = view(id, true);
+		if (result) return result;
+		const t2 = now();
+		return makeObservation({
+			snapshot: makeUnavailableSnapshot(id, "INVALIDATED"),
+			freshness: "live",
+			checkedAtMs: t2,
+			nowMs: t2,
+			latestErrorCode: "INVALIDATED"
+		});
+	};
+	return {
+		read: (ids, opts) => Effect.promise(() => Promise.all(ids.map((id) => readOne(id, opts?.force === true)))),
+		peek: (id) => view(id, false),
+		invalidate: (id) => {
+			for (const target of id ? [id] : [
+				"codex",
+				"claude",
+				"antigravity"
+			]) {
+				generations.set(target, (generations.get(target) ?? 0) + 1);
+				slots.delete(target);
+			}
+		}
+	};
+}
+export { readAll as a, parseAgyVersion as c, readCodex as d, CodexTransportError as f, isProviderId as i, parseAntigravityUsageReport as l, parseCodexRateLimits as m, PROVIDER_METADATA as n, parseClaudeOAuthUsage as o, requestCodexRateLimits as p, builtInProviders as r, readClaude as s, createQuotaService as t, readAntigravity as u };