@kunkun.sh/kuota 0.0.0-stage → 0.1.0

package/dist/history-oOXsjdWR.mjs

@@ -0,0 +1,236 @@
+import { r as decodeHistoryEvent } from "./dist-CIjerpSd.mjs";
+import "./src-y_QKmTyj.mjs";
+import { Either } from "effect";
+import { mkdir, open, readFile, readdir, rm, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+// ../history/src/local-jsonl.ts
+const FILE = /^events-(\d{4}-\d{2}-\d{2})(?:\.(\d+))?\.jsonl$/;
+const DATE = /^\d{4}-\d{2}-\d{2}$/;
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const utcDate = (iso) => new Date(iso).toISOString().slice(0, 10);
+async function listParts(directory, date) {
+	let names;
+	try {
+		names = await readdir(directory);
+	} catch {
+		return [];
+	}
+	const parts = [];
+	for (const name of names) {
+		const match = FILE.exec(name);
+		if (!match || !DATE.test(match[1])) continue;
+		if (date !== void 0 && match[1] !== date) continue;
+		parts.push({
+			name,
+			date: match[1],
+			part: match[2] === void 0 ? 0 : Number(match[2])
+		});
+	}
+	return parts.sort((a, b) => a.date.localeCompare(b.date) || a.part - b.part);
+}
+function partName(date, part) {
+	return part === 0 ? `events-${date}.jsonl` : `events-${date}.${part}.jsonl`;
+}
+async function parseFile(path) {
+	let text;
+	try {
+		text = await readFile(path, "utf8");
+	} catch {
+		return {
+			events: [],
+			invalid: 0
+		};
+	}
+	const events = [];
+	let invalid = 0;
+	for (const line of text.split("\n")) {
+		if (line.trim() === "") continue;
+		try {
+			const decoded = decodeHistoryEvent(JSON.parse(line));
+			if (Either.isRight(decoded)) events.push(decoded.right);
+			else invalid++;
+		} catch {
+			invalid++;
+		}
+	}
+	return {
+		events,
+		invalid
+	};
+}
+function createLocalJsonlJournal(options) {
+	const directory = options.directory;
+	const maxFileBytes = options.maxFileBytes ?? 16777216;
+	const retentionDays = options.retentionDays ?? 400;
+	const doSync = options.fsync ?? true;
+	const lockStaleMs = options.lockStaleMs ?? 3e4;
+	const lockTimeoutMs = options.lockTimeoutMs ?? 15e3;
+	const lockPath = join(directory, ".lock");
+	let queue = Promise.resolve();
+	async function withLock(fn) {
+		await mkdir(directory, {
+			recursive: true,
+			mode: 448
+		});
+		const deadline = Date.now() + lockTimeoutMs;
+		for (;;) try {
+			const handle = await open(lockPath, "wx", 384);
+			await handle.writeFile(String(process.pid));
+			await handle.close();
+			break;
+		} catch (error) {
+			if (error.code !== "EEXIST") throw error;
+			try {
+				const info = await stat(lockPath);
+				if (Date.now() - info.mtimeMs > lockStaleMs) {
+					await rm(lockPath, { force: true });
+					continue;
+				}
+			} catch {
+				continue;
+			}
+			if (Date.now() > deadline) throw new Error("JOURNAL_LOCK_TIMEOUT");
+			await sleep(5);
+		}
+		try {
+			return await fn();
+		} finally {
+			await rm(lockPath, { force: true });
+		}
+	}
+	async function appendDate(date, events) {
+		const parts = await listParts(directory, date);
+		const known = /* @__PURE__ */ new Set();
+		for (const part of parts) for (const event of (await parseFile(join(directory, part.name))).events) known.add(event.eventId);
+		const fresh = [];
+		let duplicates = 0;
+		for (const event of events) if (known.has(event.eventId)) duplicates++;
+		else {
+			known.add(event.eventId);
+			fresh.push(event);
+		}
+		if (fresh.length === 0) return {
+			written: 0,
+			duplicates
+		};
+		let partNumber = parts.length === 0 ? 0 : parts[parts.length - 1].part;
+		let path = join(directory, partName(date, partNumber));
+		let size = 0;
+		let endsWithNewline = true;
+		try {
+			size = (await stat(path)).size;
+			if (size > 0) {
+				const handle = await open(path, "r");
+				const last = Buffer.alloc(1);
+				await handle.read(last, 0, 1, size - 1);
+				await handle.close();
+				endsWithNewline = last[0] === 10;
+			}
+		} catch {
+			size = 0;
+		}
+		const buckets = [[]];
+		let current = size;
+		for (const event of fresh) {
+			const line = JSON.stringify(event) + "\n";
+			if (current > 0 && current + line.length > maxFileBytes) {
+				buckets.push([]);
+				current = 0;
+			}
+			buckets[buckets.length - 1].push(line);
+			current += line.length;
+		}
+		for (const [index, lines] of buckets.entries()) {
+			if (index > 0) {
+				partNumber += 1;
+				path = join(directory, partName(date, partNumber));
+				endsWithNewline = true;
+			}
+			const payload = (endsWithNewline ? "" : "\n") + lines.join("");
+			const handle = await open(path, "a", 384);
+			try {
+				await handle.write(payload);
+				if (doSync) await handle.sync();
+			} finally {
+				await handle.close();
+			}
+		}
+		return {
+			written: fresh.length,
+			duplicates
+		};
+	}
+	async function readAll(opts) {
+		const fromMs = Date.parse(opts.from);
+		const toMs = Date.parse(opts.to);
+		if (!Number.isFinite(fromMs) || !Number.isFinite(toMs)) throw new Error("INVALID_RANGE");
+		const fromDate = utcDate(opts.from);
+		const toDate = utcDate(opts.to);
+		const events = [];
+		let invalidLines = 0;
+		for (const part of await listParts(directory)) {
+			if (part.date < fromDate || part.date > toDate) continue;
+			const parsed = await parseFile(join(directory, part.name));
+			invalidLines += parsed.invalid;
+			for (const event of parsed.events) {
+				const t = Date.parse(event.observedAt);
+				if (t < fromMs || t > toMs) continue;
+				if (opts.provider !== void 0 && event.provider !== opts.provider) continue;
+				if (opts.windowId !== void 0 && event.windowId !== opts.windowId) continue;
+				events.push(event);
+			}
+		}
+		return {
+			events,
+			invalidLines
+		};
+	}
+	return {
+		append(events) {
+			for (const event of events) if (Either.isLeft(decodeHistoryEvent(event))) return Promise.reject(/* @__PURE__ */ new Error("INVALID_HISTORY_EVENT"));
+			const run = queue.then(() => withLock(async () => {
+				const byDate = /* @__PURE__ */ new Map();
+				for (const event of events) {
+					const date = utcDate(event.observedAt);
+					byDate.set(date, [...byDate.get(date) ?? [], event]);
+				}
+				let written = 0;
+				let duplicates = 0;
+				for (const [date, list] of [...byDate].sort(([a], [b]) => a.localeCompare(b))) {
+					const result = await appendDate(date, list);
+					written += result.written;
+					duplicates += result.duplicates;
+				}
+				return {
+					written,
+					duplicates
+				};
+			}));
+			queue = run.catch(() => void 0);
+			return run;
+		},
+		readAll,
+		async *read(opts) {
+			for (const event of (await readAll(opts)).events) yield event;
+		},
+		async applyRetention(now = /* @__PURE__ */ new Date()) {
+			const cutoffMs = Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate()) - (Math.max(1, retentionDays) - 1) * 864e5;
+			const cutoff = new Date(cutoffMs).toISOString().slice(0, 10);
+			return queue.then(() => withLock(async () => {
+				let removed = 0;
+				for (const part of await listParts(directory)) if (part.date < cutoff) {
+					await rm(join(directory, part.name), { force: true });
+					removed++;
+				}
+				return removed;
+			}));
+		}
+	};
+}
+function defaultHistoryDirectory(env = process.env, platform = process.platform) {
+	if (env.KUOTA_HISTORY_DIR) return env.KUOTA_HISTORY_DIR;
+	if (platform === "darwin") return join(homedir(), "Library", "Application Support", "kuota", "history");
+	return join(env.XDG_DATA_HOME ?? join(homedir(), ".local", "share"), "kuota", "history");
+}
+export { defaultHistoryDirectory as n, createLocalJsonlJournal as t };

package/dist/history.d.mts

@@ -0,0 +1,3 @@
+import { d as decodeHistoryEvent, f as historyEventsFromSnapshot } from "./index-NHzh2TGn.mjs";
+import { a as createLocalJsonlJournal, i as ReadResult, n as JournalStore, o as defaultHistoryDirectory, r as ReadOptions, t as JournalOptions } from "./history-G4o4HVvW.mjs";
+export { type JournalOptions, type JournalStore, type ReadOptions, type ReadResult, createLocalJsonlJournal, decodeHistoryEvent, defaultHistoryDirectory, historyEventsFromSnapshot };

package/dist/history.mjs

@@ -0,0 +1,3 @@
+import { n as decodeHistoryEvent, r as historyEventsFromSnapshot } from "./src-y_QKmTyj.mjs";
+import { n as defaultHistoryDirectory, t as createLocalJsonlJournal } from "./history-oOXsjdWR.mjs";
+export { createLocalJsonlJournal, decodeHistoryEvent, defaultHistoryDirectory, historyEventsFromSnapshot };

package/dist/index-2k6FkhpT.d.mts

@@ -0,0 +1,81 @@
+import { S as QuotaSnapshot, b as ProviderId, m as QuotaObservation } from "./index-NHzh2TGn.mjs";
+import { Effect } from "effect";
+type CodexTransportErrorCode = "BINARY_NOT_FOUND" | "TIMEOUT" | "PROTOCOL_ERROR";
+/** Fixed, safe error messages: never forward stderr or a raw RPC response. */
+declare class CodexTransportError extends Error {
+  readonly code: CodexTransportErrorCode;
+  constructor(code: CodexTransportErrorCode);
+}
+interface CodexRpcOptions {
+  binary?: string;
+  args?: readonly string[];
+  timeoutMs?: number;
+}
+/** One bounded RPC session. Never spawns a bare Codex TUI and never prints raw output. */
+declare function requestCodexRateLimits(options?: CodexRpcOptions): Promise<unknown>;
+/** Parses only the non-sensitive subset of the Codex app-server v2 quota response. */
+declare function parseCodexRateLimits(raw: unknown, fetchedAt?: Date): QuotaSnapshot;
+declare function readCodex(options?: CodexRpcOptions): Effect.Effect<QuotaSnapshot>;
+interface QuotaProvider {
+  id: ProviderId;
+  label: string;
+  read: () => Effect.Effect<QuotaSnapshot, unknown>;
+}
+interface ProviderMetadata {
+  id: ProviderId;
+  label: string;
+  implemented: boolean;
+  source: string;
+}
+declare const PROVIDER_METADATA: readonly ProviderMetadata[];
+/** Static names are extensible to runtime manifests in the later plugin phase. */
+declare function isProviderId(value: string): value is ProviderId;
+declare function builtInProviders(): QuotaProvider[];
+/** One failed adapter never prevents other providers from reporting. */
+declare function readAll(ids: readonly ProviderId[], providers?: readonly QuotaProvider[]): Effect.Effect<readonly QuotaSnapshot[]>;
+/** Parses agy >=1.1.11's structured `-p /usage --output-format json` response. */
+declare function parseAntigravityUsageReport(raw: unknown): QuotaSnapshot;
+/** Version strings with suffixes are intentionally rejected to avoid guessing support. */
+declare function parseAgyVersion(value: string): boolean;
+interface AgyOptions {
+  binary?: string;
+  timeoutMs?: number;
+  maxOutputBytes?: number;
+}
+/** No new account login. Existing agy credentials only, guarded from browser launch and auto-update. */
+declare function readAntigravity(options?: AgyOptions): Effect.Effect<QuotaSnapshot>;
+/** Claude API reports utilization (used percent), not remaining percent. */
+declare function parseClaudeOAuthUsage(raw: unknown): QuotaSnapshot;
+interface ClaudeOptions {
+  /** Manually provided existing Claude Code OAuth token; never use Anthropic API keys here. */
+  token?: string;
+  credentialsFile?: string;
+  fetchImpl?: typeof fetch;
+  timeoutMs?: number;
+}
+/** No Keychain UI access, credential refresh, browser sign-in or CLI session side effects. */
+declare function readClaude(options?: ClaudeOptions): Effect.Effect<QuotaSnapshot>;
+type RefreshPolicy = Readonly<{
+  successTtlMs: number;
+  errorRetryMs: number;
+  authRetryMs: number;
+  rateLimitCooldownMs: number;
+  staleMaxAgeMs: number;
+}>;
+interface QuotaService {
+  read(ids: readonly ProviderId[], options?: {
+    force?: boolean;
+  }): Effect.Effect<readonly QuotaObservation[]>;
+  peek(id: ProviderId): QuotaObservation | null;
+  invalidate(id?: ProviderId): void;
+}
+/**
+ * Process-local TTL cache with per-provider singleflight, failure cooldowns and honest
+ * stale labelling. Only normalized snapshots are retained.
+ */
+declare function createQuotaService(options?: {
+  providers?: readonly QuotaProvider[];
+  now?: () => number;
+  policies?: Partial<Record<ProviderId, Partial<RefreshPolicy>>>;
+}): QuotaService;
+export { CodexRpcOptions as _, readClaude as a, readAntigravity as c, QuotaProvider as d, builtInProviders as f, parseCodexRateLimits as g, readCodex as h, parseClaudeOAuthUsage as i, PROVIDER_METADATA as l, readAll as m, RefreshPolicy as n, parseAgyVersion as o, isProviderId as p, createQuotaService as r, parseAntigravityUsageReport as s, QuotaService as t, ProviderMetadata as u, CodexTransportError as v, requestCodexRateLimits as y };

package/dist/index-NHzh2TGn.d.mts

@@ -0,0 +1,168 @@
+import { Either, Schema } from "effect";
+declare const ProviderIdSchema: Schema.Literal<["codex", "claude", "antigravity"]>;
+type ProviderId = Schema.Schema.Type<typeof ProviderIdSchema>;
+declare const QuotaStatusSchema: Schema.Literal<["ok", "partial", "unauthenticated", "unavailable", "unsupported", "error"]>;
+type QuotaStatus = Schema.Schema.Type<typeof QuotaStatusSchema>;
+declare const QuotaWindowSchema: Schema.Struct<{
+  windowId: typeof Schema.String;
+  usedPercent: Schema.NullOr<typeof Schema.Number>;
+  remainingPercent: Schema.NullOr<typeof Schema.Number>;
+  resetAt: Schema.NullOr<typeof Schema.String>;
+}>;
+type QuotaWindow = Schema.Schema.Type<typeof QuotaWindowSchema>;
+declare const QuotaSnapshotSchema: Schema.Struct<{
+  provider: Schema.Literal<["codex", "claude", "antigravity"]>;
+  status: Schema.Literal<["ok", "partial", "unauthenticated", "unavailable", "unsupported", "error"]>;
+  fetchedAt: typeof Schema.String;
+  source: typeof Schema.String;
+  windows: Schema.Array$<Schema.Struct<{
+    windowId: typeof Schema.String;
+    usedPercent: Schema.NullOr<typeof Schema.Number>;
+    remainingPercent: Schema.NullOr<typeof Schema.Number>;
+    resetAt: Schema.NullOr<typeof Schema.String>;
+  }>>;
+  errorCode: Schema.NullOr<typeof Schema.String>;
+}>;
+type QuotaSnapshot = Schema.Schema.Type<typeof QuotaSnapshotSchema>;
+type ProviderErrorCode = "BINARY_NOT_FOUND" | "AUTH_REQUIRED" | "TIMEOUT" | "PROTOCOL_ERROR" | "UNSUPPORTED" | "UNKNOWN";
+interface WindowInput {
+  windowId: string;
+  usedPercent?: unknown;
+  resetAt?: unknown;
+}
+declare function normalizeWindow(input: WindowInput): QuotaWindow;
+/** Whitelist public response fields: never forward token-like keys or provider raw payloads. */
+declare function redactSnapshot(input: Record<string, unknown>): QuotaSnapshot;
+declare function makeUnavailableSnapshot(provider: ProviderId, errorCode: string, status?: QuotaStatus): QuotaSnapshot;
+type Freshness = "live" | "cached" | "stale";
+/** Non-breaking wrapper: QuotaSnapshot itself (and status --json schemaVersion 1) is unchanged. */
+interface QuotaObservation {
+  readonly snapshot: QuotaSnapshot;
+  readonly freshness: Freshness;
+  readonly observedAt: string;
+  readonly checkedAt: string;
+  readonly ageMs: number;
+  readonly nextAttemptAt: string | null;
+  readonly latestErrorCode: string | null;
+}
+/**
+ * Pure constructor. If `snapshot.fetchedAt` is not a valid timestamp we fall back to the
+ * injected `checkedAtMs` as the observation time, so no NaN / Invalid Date is ever emitted.
+ */
+declare function makeObservation(input: {
+  snapshot: QuotaSnapshot;
+  freshness: Freshness;
+  checkedAtMs: number;
+  nowMs: number;
+  nextAttemptAtMs?: number | null;
+  latestErrorCode?: string | null;
+}): QuotaObservation;
+type WindowSemantics = "fixed" | "rolling" | "first_use" | "unknown";
+interface WindowProfile {
+  readonly semantics: WindowSemantics;
+  readonly durationMs: number | null;
+}
+/**
+ * Window cadence heuristics, derived from window ids the adapters emit. Only cadences named in
+ * the id (5h / weekly / daily) are trusted; everything else stays `unknown` rather than guessed.
+ * Codex `primary` / `secondary` follow the documented 5h / weekly convention of its app-server.
+ */
+declare function windowProfile(provider: ProviderId, windowId: string, resetAt?: string | null, now?: Date): WindowProfile;
+declare const QuotaHistoryEventV1Schema: Schema.Struct<{
+  schemaVersion: Schema.Literal<[1]>;
+  kind: Schema.Literal<["quota_observed", "quota_unavailable", "usage_observed"]>;
+  eventId: typeof Schema.String;
+  observedAt: Schema.filter<typeof Schema.String>;
+  recordedAt: Schema.filter<typeof Schema.String>;
+  provider: typeof Schema.String;
+  accountScope: Schema.NullOr<typeof Schema.String>;
+  deviceId: typeof Schema.String;
+  windowId: typeof Schema.String;
+  epochId: Schema.NullOr<typeof Schema.String>;
+  semantics: Schema.Literal<["fixed", "rolling", "first_use", "unknown"]>;
+  startAt: Schema.NullOr<Schema.filter<typeof Schema.String>>;
+  resetAt: Schema.NullOr<Schema.filter<typeof Schema.String>>;
+  usedPercent: Schema.NullOr<Schema.filter<typeof Schema.Number>>;
+  remainingPercent: Schema.NullOr<Schema.filter<typeof Schema.Number>>;
+  source: typeof Schema.String;
+  state: Schema.Literal<["ok", "partial", "stale", "error", "unauthenticated"]>;
+  errorCode: Schema.NullOr<typeof Schema.String>;
+  usage: Schema.optional<Schema.Struct<{
+    inputTokens: Schema.optional<typeof Schema.Number>;
+    outputTokens: Schema.optional<typeof Schema.Number>;
+    cacheReadTokens: Schema.optional<typeof Schema.Number>;
+    cacheWriteTokens: Schema.optional<typeof Schema.Number>;
+    model: Schema.optional<typeof Schema.String>;
+    estimatedUsd: Schema.optional<typeof Schema.Number>;
+  }>>;
+}>;
+type QuotaHistoryEventV1 = Schema.Schema.Type<typeof QuotaHistoryEventV1Schema>;
+/** Strict decode: unknown (possibly secret-bearing) fields are rejected, not silently kept. */
+declare function decodeHistoryEvent(input: unknown): Either.Either<QuotaHistoryEventV1, unknown>;
+interface HistoryEventOptions {
+  deviceId: string;
+  accountScope: string | null;
+  recordedAt: string;
+  /** Mark observations that came from a stale cache rather than a live probe. */
+  stale?: boolean;
+  semanticsForWindow?: (id: string) => WindowSemantics;
+  startForWindow?: (id: string) => string | null;
+}
+/** Pure normalization: one event per measurable window, or one sanitized unavailable event. */
+declare function historyEventsFromSnapshot(snapshot: QuotaSnapshot, options: HistoryEventOptions): readonly QuotaHistoryEventV1[];
+type ForecastQuality = "insufficient" | "low" | "medium" | "high" | "unsupported";
+type ForecastMode = "all-window" | "recent-activity";
+interface ForecastInput {
+  now: Date;
+  resetAt: Date | null;
+  observations: readonly QuotaHistoryEventV1[];
+  mode: ForecastMode;
+}
+interface ForecastResult {
+  slopePercentPerHour: number | null;
+  exhaustedAt: string | null;
+  projectedUsedAtResetPercent: number | null;
+  sampleCount: number;
+  observedSpanHours: number;
+  quality: ForecastQuality;
+  reasons: readonly string[];
+}
+interface EpochSegment {
+  events: QuotaHistoryEventV1[];
+  /** Why this segment started (null for the first). */
+  reason: "EPOCH_RESET_DETECTED" | "USAGE_DECREASE_SPLIT" | null;
+}
+declare function isMeasurable(e: QuotaHistoryEventV1): boolean;
+/**
+ * Reset/epoch detection. A new segment starts when the provider-reported reset boundary moves
+ * (beyond jitter tolerance) or when used% drops (credit / unannounced reset). Fixed windows only
+ * ever compare points inside one segment.
+ */
+declare function detectEpochs(events: readonly QuotaHistoryEventV1[]): EpochSegment[];
+declare function forecastQuota(input: ForecastInput): ForecastResult;
+interface QuotaForecastV1 {
+  schemaVersion: 1;
+  provider: string;
+  windowId: string;
+  computedAt: string;
+  currentUsedPercent: number | null;
+  idealUsedPercent: number | null;
+  observedSpanHours: number;
+  sampleCount: number;
+  slopePercentPerHour: number | null;
+  exhaustedAt: string | null;
+  projectedUsedAtResetPercent: number | null;
+  expectedTimeToLimitHours: number | null;
+  mode: ForecastMode;
+  quality: ForecastQuality;
+  reasons: string[];
+}
+/** Account-safe wrapper: only events sharing the newest event's accountScope are considered. */
+declare function buildForecastV1(input: {
+  now: Date;
+  provider: string;
+  windowId: string;
+  observations: readonly QuotaHistoryEventV1[];
+  mode: ForecastMode;
+}): QuotaForecastV1;
+export { QuotaSnapshotSchema as C, QuotaWindowSchema as D, QuotaWindow as E, QuotaSnapshot as S, QuotaStatusSchema as T, normalizeWindow as _, detectEpochs as a, ProviderId as b, QuotaHistoryEventV1 as c, decodeHistoryEvent as d, historyEventsFromSnapshot as f, makeUnavailableSnapshot as g, makeObservation as h, buildForecastV1 as i, QuotaHistoryEventV1Schema as l, QuotaObservation as m, ForecastQuality as n, forecastQuota as o, windowProfile as p, QuotaForecastV1 as r, isMeasurable as s, ForecastMode as t, WindowProfile as u, redactSnapshot as v, QuotaStatus as w, ProviderIdSchema as x, ProviderErrorCode as y };

package/dist/index.d.mts

@@ -0,0 +1,7 @@
+import { parseProviderQuota } from "./parsers.mjs";
+import { i as calculatePace, n as PaceInput, r as PaceResult, t as sha256Hex } from "./metrics-D7oNul_9.mjs";
+import { a as createLocalJsonlJournal, i as ReadResult, n as JournalStore, o as defaultHistoryDirectory, r as ReadOptions, t as JournalOptions } from "./history-G4o4HVvW.mjs";
+import { _ as CodexRpcOptions, a as readClaude, c as readAntigravity, d as QuotaProvider, f as builtInProviders, g as parseCodexRateLimits, h as readCodex, i as parseClaudeOAuthUsage, l as PROVIDER_METADATA, m as readAll, n as RefreshPolicy, o as parseAgyVersion, p as isProviderId, r as createQuotaService, s as parseAntigravityUsageReport, t as QuotaService, u as ProviderMetadata, v as CodexTransportError, y as requestCodexRateLimits } from "./index-2k6FkhpT.mjs";
+import "./providers.mjs";
+import { C as QuotaSnapshotSchema, D as QuotaWindowSchema, E as QuotaWindow, S as QuotaSnapshot, T as QuotaStatusSchema, _ as normalizeWindow, a as detectEpochs, b as ProviderId, c as QuotaHistoryEventV1, d as decodeHistoryEvent, f as historyEventsFromSnapshot, g as makeUnavailableSnapshot, h as makeObservation, i as buildForecastV1, l as QuotaHistoryEventV1Schema, n as ForecastQuality, o as forecastQuota, p as windowProfile, r as QuotaForecastV1, s as isMeasurable, t as ForecastMode, u as WindowProfile, v as redactSnapshot, w as QuotaStatus, x as ProviderIdSchema, y as ProviderErrorCode } from "./index-NHzh2TGn.mjs";
+export { type CodexRpcOptions, CodexTransportError, type ForecastMode, type ForecastQuality, type JournalOptions, type JournalStore, PROVIDER_METADATA, type PaceInput, type PaceResult, type ProviderErrorCode, type ProviderId, ProviderIdSchema, type ProviderMetadata, type QuotaForecastV1, type QuotaHistoryEventV1, QuotaHistoryEventV1Schema, type QuotaProvider, type QuotaService, type QuotaSnapshot, QuotaSnapshotSchema, type QuotaStatus, QuotaStatusSchema, type QuotaWindow, QuotaWindowSchema, type ReadOptions, type ReadResult, type RefreshPolicy, type WindowProfile, buildForecastV1, builtInProviders, calculatePace, createLocalJsonlJournal, createQuotaService, decodeHistoryEvent, defaultHistoryDirectory, detectEpochs, forecastQuota, historyEventsFromSnapshot, isMeasurable, isProviderId, makeObservation, makeUnavailableSnapshot, normalizeWindow, parseAgyVersion, parseAntigravityUsageReport, parseClaudeOAuthUsage, parseCodexRateLimits, parseProviderQuota, readAll, readAntigravity, readClaude, readCodex, redactSnapshot, requestCodexRateLimits, sha256Hex, windowProfile };

package/dist/index.mjs

@@ -0,0 +1,7 @@
+import { a as readAll, c as parseAgyVersion, d as readCodex, f as CodexTransportError, i as isProviderId, l as parseAntigravityUsageReport, m as parseCodexRateLimits, n as PROVIDER_METADATA, o as parseClaudeOAuthUsage, p as requestCodexRateLimits, r as builtInProviders, s as readClaude, t as createQuotaService, u as readAntigravity } from "./src-C48Ew_L9.mjs";
+import { parseProviderQuota } from "./parsers.mjs";
+import { a as makeObservation, c as normalizeWindow, i as isMeasurable, l as redactSnapshot, n as detectEpochs, o as calculatePace, r as forecastQuota, s as makeUnavailableSnapshot, t as buildForecastV1 } from "./metrics-Bzmrfgn-.mjs";
+import { n as defaultHistoryDirectory, t as createLocalJsonlJournal } from "./history-oOXsjdWR.mjs";
+import "./providers.mjs";
+import { a as sha256Hex, c as QuotaStatusSchema, i as windowProfile, l as QuotaWindowSchema, n as decodeHistoryEvent, o as ProviderIdSchema, r as historyEventsFromSnapshot, s as QuotaSnapshotSchema, t as QuotaHistoryEventV1Schema } from "./src-y_QKmTyj.mjs";
+export { CodexTransportError, PROVIDER_METADATA, ProviderIdSchema, QuotaHistoryEventV1Schema, QuotaSnapshotSchema, QuotaStatusSchema, QuotaWindowSchema, buildForecastV1, builtInProviders, calculatePace, createLocalJsonlJournal, createQuotaService, decodeHistoryEvent, defaultHistoryDirectory, detectEpochs, forecastQuota, historyEventsFromSnapshot, isMeasurable, isProviderId, makeObservation, makeUnavailableSnapshot, normalizeWindow, parseAgyVersion, parseAntigravityUsageReport, parseClaudeOAuthUsage, parseCodexRateLimits, parseProviderQuota, readAll, readAntigravity, readClaude, readCodex, redactSnapshot, requestCodexRateLimits, sha256Hex, windowProfile };