@openlimiter/connectors 0.2.0 → 1.2.0

package/dist/fixtures.js

@@ -1,5 +1,24 @@
 /**
- * Synthetic fixtures.
+ * Connector fixtures, in three classes that mean three different things.
+ *
+ * The audit found the failure this file now exists to prevent: the Claude
+ * fixture had been written to match our parser instead of the provider, so the
+ * test suite proved only that our code agreed with itself while the shipped
+ * connector could not read a real payload. A fixture is worth nothing unless
+ * you can say where its shape came from, so every fixture below is filed under
+ * one of three classes and carries its own provenance.
+ *
+ * documented    Built from the provider's own published example. Carries the
+ *               documentation URL and the date a human last read it. This is
+ *               the only class that can prove we match a provider.
+ *
+ * sanitizedLive Built from a real capture on a real account, with the values
+ *               scrubbed. Proves the documentation matches reality. A capture
+ *               that does not exist yet is present as an explicit placeholder
+ *               that tests skip out loud; it is never invented.
+ *
+ * malformed     Hostile, truncated and edge shaped input. Proves the parser
+ *               fails closed rather than guessing.
  *
  * Every reset timestamp is derived from a supplied clock instead of a pinned
  * calendar date, so a fixture parsed against the real current time still lands
@@ -11,21 +30,73 @@ const FIVE_HOURS = 18_000;
 const ONE_DAY = 86_400;
 const SEVEN_DAYS = 604_800;
 const THIRTY_ONE_DAYS = 2_678_400;
+/** Docs URL for the one interface a provider publishes for us. */
+export const CLAUDE_STATUSLINE_DOCS_URL = "https://code.claude.com/docs/en/statusline";
+/** Docs URL for the one remote interface with a published response shape. */
+export const OPENROUTER_CREDITS_DOCS_URL = "https://openrouter.ai/docs/api-reference/get-credits";
+export const GROK_BILLING_SOURCE_URL = "https://github.com/xai-org/grok-build/blob/main/crates/codegen/xai-grok-shell/src/extensions/billing.rs";
+export const KIMI_USAGE_SOURCE_URL = "https://github.com/MoonshotAI/kimi-code/blob/main/packages/oauth/src/managed-usage.ts";
+export const GEMINI_CLI_QUOTA_SOURCE_URL = "https://github.com/google-gemini/gemini-cli/blob/main/packages/core/src/code_assist/server.ts";
+/** The day a human last read both pages above against this file. */
+export const FIXTURE_REVIEWED_AT = "2026-08-10";
 function offset(now, seconds) {
     const base = Date.parse(now);
     const anchor = Number.isFinite(base) ? base : Date.parse(FIXTURE_NOW);
     return new Date(anchor + seconds * 1_000).toISOString();
 }
+/**
+ * A reset instant in the encoding Claude Code actually uses.
+ *
+ * Whole Unix seconds, never milliseconds, because handing a millisecond stamp
+ * to a seconds field is the exact mistake this connector's fixtures exist to
+ * catch. The instant moves with the supplied clock; the encoding does not.
+ */
+/**
+ * A reset instant in the encoding Google's quota summary uses.
+ *
+ * RFC3339 with an explicit offset, and with the seven fractional digits the
+ * Antigravity client actually writes, because a fixture that prints three would
+ * never exercise the normalisation the parser has to do.
+ */
+function rfc3339Offset(now, seconds) {
+    const base = Date.parse(now);
+    const anchor = Number.isFinite(base) ? base : Date.parse(FIXTURE_NOW);
+    return new Date(anchor + seconds * 1_000)
+        .toISOString()
+        .replace(/\.(\d{3})Z$/u, ".$10000Z");
+}
+function epochOffset(now, seconds) {
+    const base = Date.parse(now);
+    const anchor = Number.isFinite(base) ? base : Date.parse(FIXTURE_NOW);
+    return Math.floor(anchor / 1_000) + seconds;
+}
+/* ------------------------------------------------------------------ *
+ * Demo builders
+ *
+ * These are the payloads the CLI demo and the web sample mode render. They
+ * are synthetic, and their percentages are chosen so the demo lands one meter
+ * in each colour band. Their SHAPES are the documented shapes and nothing
+ * else: a demo that renders a shape no provider emits is how the last contract
+ * mismatch survived a full test suite.
+ * ------------------------------------------------------------------ */
+/**
+ * The Claude demo payload, in the documented shape.
+ *
+ * Forty two and sixty four are invented readings kept from the previous demo so
+ * every surface renders the same numbers it did before. The field names and the
+ * epoch seconds encoding are the provider's, taken from the documentation cited
+ * on parseClaudePayload.
+ */
 export function claudeFixture(now = FIXTURE_NOW) {
     return {
         rate_limits: {
             five_hour: {
-                utilization: 42,
-                resets_at: offset(now, FIVE_HOURS)
+                used_percentage: 42,
+                resets_at: epochOffset(now, FIVE_HOURS)
             },
             seven_day: {
-                utilization: 64,
-                resets_at: offset(now, SEVEN_DAYS)
+                used_percentage: 64,
+                resets_at: epochOffset(now, SEVEN_DAYS)
             }
         }
     };
@@ -62,22 +133,132 @@ export function openrouterFixture() {
  */
 export function codexFixture(now = FIXTURE_NOW) {
     return {
-        rate_limits: {
+        rate_limit: {
             primary_window: {
                 used_percent: 84,
-                reset_at: offset(now, FIVE_HOURS)
+                reset_at: epochOffset(now, FIVE_HOURS),
+                limit_window_seconds: FIVE_HOURS
+            }
+        }
+    };
+}
+/**
+ * A Codex window that states a percent and no reset time at all.
+ *
+ * The reference reader passes `reset_at` straight through, so when the provider
+ * omits it the window arrives with a real percent and no countdown. This is a
+ * separate builder rather than a change to `codexFixture` above, so the demo
+ * numbers and every existing expectation stay exactly as they were, and the
+ * no reset case gets its own fixture to exercise. The window keeps its length,
+ * so it still names itself FIVE_HOUR; the only thing missing is the reset.
+ */
+export function codexNoResetFixture(now = FIXTURE_NOW) {
+    void now;
+    return {
+        rate_limit: {
+            primary_window: {
+                used_percent: 73,
+                limit_window_seconds: FIVE_HOURS
             }
         }
     };
 }
+/**
+ * The Antigravity demo payload, in the observed shape.
+ *
+ * Two windows on the tracked pool, and a third party pool beside it that the
+ * parser must leave alone. The five hour window is the binding one at 28
+ * percent, which keeps the demo's routing advice exactly where it was: the
+ * policy stops recommending a provider at 80, so Codex at 84 drops out and
+ * Antigravity is the lowest reading still in the running.
+ *
+ * `remainingFraction` is what the provider states, so 0.72 remaining is 28 used.
+ */
 export function antigravityFixture(now = FIXTURE_NOW) {
     return {
-        quota: {
-            used_percent: 28,
-            reset_at: offset(now, ONE_DAY)
+        groups: [
+            {
+                displayName: "Gemini models",
+                buckets: [
+                    {
+                        bucketId: "gemini-pro-5h",
+                        window: "5h",
+                        remainingFraction: 0.72,
+                        resetTime: rfc3339Offset(now, FIVE_HOURS)
+                    },
+                    {
+                        bucketId: "gemini-pro-weekly",
+                        window: "weekly",
+                        remainingFraction: 0.9,
+                        resetTime: rfc3339Offset(now, SEVEN_DAYS)
+                    }
+                ]
+            },
+            {
+                displayName: "Third party models",
+                buckets: [
+                    {
+                        bucketId: "3p-claude-5h",
+                        window: "5h",
+                        remainingFraction: 0.5,
+                        resetTime: rfc3339Offset(now, FIVE_HOURS)
+                    }
+                ]
+            }
+        ]
+    };
+}
+export function geminiCliFixture(now = FIXTURE_NOW) {
+    return {
+        buckets: [
+            {
+                remainingFraction: 0.75,
+                resetTime: offset(now, SEVEN_DAYS),
+                tokenType: "REQUESTS",
+                modelId: "gemini-3.1-pro-preview"
+            },
+            {
+                remainingFraction: 1,
+                resetTime: offset(now, SEVEN_DAYS),
+                tokenType: "REQUESTS",
+                modelId: "gemini-3-flash-preview"
+            }
+        ]
+    };
+}
+export function grokFixture(now = FIXTURE_NOW) {
+    return {
+        config: {
+            creditUsagePercent: 42.5,
+            currentPeriod: {
+                type: "USAGE_PERIOD_TYPE_WEEKLY",
+                start: offset(now, -ONE_DAY),
+                end: offset(now, SEVEN_DAYS)
+            },
+            onDemandCap: { val: 5000 },
+            onDemandUsed: { val: 300 }
         }
     };
 }
+export function kimiFixture(now = FIXTURE_NOW) {
+    return {
+        usage: {
+            used: "214",
+            limit: "2048",
+            remaining: "1834",
+            resetTime: offset(now, SEVEN_DAYS)
+        },
+        limits: [{
+                window: { duration: 5, timeUnit: "TIME_UNIT_HOUR" },
+                detail: {
+                    used: "139",
+                    limit: "200",
+                    remaining: "61",
+                    resetTime: offset(now, FIVE_HOURS)
+                }
+            }]
+    };
+}
 /**
  * The one fixture in the red band.
  *
@@ -87,13 +268,35 @@ export function antigravityFixture(now = FIXTURE_NOW) {
  * the demo set now lands one meter in each of the four bands.
  */
 export function opencodeFixture(now = FIXTURE_NOW) {
-    return {
-        usage: {
-            percent: 92,
-            reset_at: offset(now, ONE_DAY),
-            account_label: "demo@example.test"
-        }
-    };
+    return opencodePage({ percent: 92, resetsIn: "20 hours" }, { percent: 40, resetsIn: "5 days 20 hours" }, { percent: 15, resetsIn: "21 days" }, now);
+}
+/** One window block as the workspace page renders it, hydration markers and all. */
+function opencodeWindowBlock(label, window) {
+    const reset = window.resetsIn === null
+        ? ""
+        : `<p class="muted">Resets in<!--/--> <!--$-->${window.resetsIn}<!--/--></p>`;
+    return `<section><h3>${label}</h3>` +
+        `<div class="bar"><span><!--$-->${String(window.percent)}%<!--/--></span></div>` +
+        reset +
+        `</section>`;
+}
+/**
+ * The OpenCode workspace page, as HTML, because that is the only place these
+ * numbers exist.
+ *
+ * Built rather than pasted so a fixture can move its numbers without anybody
+ * hand editing markup, and deliberately carrying the framework's hydration
+ * comments: a fixture of clean HTML would pass while the real page failed.
+ * The `now` parameter is accepted for symmetry with the other builders; the
+ * page states durations rather than instants, so it does not use one.
+ */
+export function opencodePage(rolling, weekly, monthly, now = FIXTURE_NOW) {
+    void now;
+    return `<!doctype html><html><body><main>` +
+        opencodeWindowBlock("Rolling Usage", rolling) +
+        opencodeWindowBlock("Weekly Usage", weekly) +
+        opencodeWindowBlock("Monthly Usage", monthly) +
+        `</main></body></html>`;
 }
 export function manualFixture(now = FIXTURE_NOW) {
     return {
@@ -110,4 +313,731 @@ export const hostileFixture = {
     value: 9e300,
     label: "Ω".repeat(200)
 };
+/**
+ * The Claude payload exactly as the documentation prints it.
+ *
+ * Values 23.5 and 41.2 and the epoch seconds encoding are the published
+ * example. Only the instant moves, forward of the supplied clock, because a
+ * reset in the past is correctly refused and would test nothing.
+ */
+export function claudeDocumentedFixture(now = FIXTURE_NOW) {
+    return {
+        rate_limits: {
+            five_hour: {
+                used_percentage: 23.5,
+                resets_at: epochOffset(now, FIVE_HOURS)
+            },
+            seven_day: {
+                used_percentage: 41.2,
+                resets_at: epochOffset(now, SEVEN_DAYS)
+            }
+        }
+    };
+}
+/**
+ * The documented example with its literal epoch numbers left alone.
+ *
+ * Frozen, because it is what pins our epoch conversion to a hand computed
+ * answer: 1738425600 is 2025-02-01T16:00:00.000Z and 1738857600 is
+ * 2025-02-06T16:00:00.000Z.
+ *
+ * Parsing it needs a clock shortly before the first of those, not merely any
+ * earlier clock. A five hour window may only reset within about eleven hours,
+ * so a clock a month back would see a five hour meter resetting a month away
+ * and refuse it, correctly.
+ */
+export const CLAUDE_DOCS_EXAMPLE_VERBATIM = {
+    rate_limits: {
+        five_hour: { used_percentage: 23.5, resets_at: 1_738_425_600 },
+        seven_day: { used_percentage: 41.2, resets_at: 1_738_857_600 }
+    }
+};
+/** The instants the two numbers above mean, computed by hand, not by code. */
+export const CLAUDE_DOCS_EXAMPLE_RESETS = {
+    five_hour: "2025-02-01T16:00:00.000Z",
+    seven_day: "2025-02-06T16:00:00.000Z"
+};
+export const documentedFixtures = [
+    {
+        id: "claude.documented.statusline",
+        connector: "claude",
+        docsUrl: CLAUDE_STATUSLINE_DOCS_URL,
+        reviewedAt: FIXTURE_REVIEWED_AT,
+        sourceStatus: "official",
+        note: "Published statusline example: used_percentage and Unix epoch seconds.",
+        expectedMeters: 2,
+        build: (now) => claudeDocumentedFixture(now)
+    },
+    {
+        id: "openrouter.documented.credits",
+        connector: "openrouter",
+        docsUrl: OPENROUTER_CREDITS_DOCS_URL,
+        reviewedAt: FIXTURE_REVIEWED_AT,
+        sourceStatus: "official",
+        note: "Published credits response: data.total_credits and data.total_usage.",
+        expectedMeters: 1,
+        build: () => openrouterFixture()
+    },
+    {
+        id: "codex.provisional.usage",
+        connector: "codex",
+        docsUrl: null,
+        reviewedAt: FIXTURE_REVIEWED_AT,
+        sourceStatus: "provisional",
+        note: "Shape observed against a real account on 2026-08-07 by the reference " +
+            "reader: rate_limit.primary_window, singular, with reset_at in epoch " +
+            "seconds. OpenAI publishes nothing, so this is design evidence only.",
+        expectedMeters: 1,
+        build: (now) => codexFixture(now)
+    },
+    {
+        id: "antigravity.provisional.quota",
+        connector: "antigravity",
+        docsUrl: null,
+        reviewedAt: FIXTURE_REVIEWED_AT,
+        sourceStatus: "provisional",
+        note: "Shape observed against a real Google AI Pro account on 2026-08-07 by " +
+            "the reference reader: groups of buckets carrying remainingFraction and " +
+            "an RFC3339 resetTime. Google publishes nothing, so this is design " +
+            "evidence only.",
+        expectedMeters: 2,
+        build: (now) => antigravityFixture(now)
+    },
+    {
+        id: "gemini-cli.official-source.quota",
+        connector: "gemini_cli",
+        docsUrl: GEMINI_CLI_QUOTA_SOURCE_URL,
+        reviewedAt: "2026-08-20",
+        sourceStatus: "official",
+        note: "The official Gemini CLI source defines the private quota response buckets.",
+        expectedMeters: 2,
+        build: (now) => geminiCliFixture(now)
+    },
+    {
+        id: "opencode.provisional.usage",
+        connector: "opencode",
+        docsUrl: null,
+        reviewedAt: FIXTURE_REVIEWED_AT,
+        sourceStatus: "provisional",
+        note: "The logged in workspace page as observed on 2026-08-03: three labelled " +
+            "windows rendered into HTML. OpenCode publishes no usage interface at " +
+            "all, so this is design evidence only and stays a scrape.",
+        expectedMeters: 3,
+        build: (now) => opencodeFixture(now)
+    },
+    {
+        id: "grok.official_source.billing",
+        connector: "grok",
+        docsUrl: GROK_BILLING_SOURCE_URL,
+        reviewedAt: FIXTURE_REVIEWED_AT,
+        sourceStatus: "official",
+        note: "The official Grok CLI source publishes the billing response fields and period vocabulary.",
+        expectedMeters: 2,
+        build: (now) => grokFixture(now)
+    },
+    {
+        id: "kimi.official_source.usages",
+        connector: "kimi",
+        docsUrl: KIMI_USAGE_SOURCE_URL,
+        reviewedAt: FIXTURE_REVIEWED_AT,
+        sourceStatus: "official",
+        note: "The official Kimi CLI source publishes the usage summary and provider defined windows.",
+        expectedMeters: 2,
+        build: (now) => kimiFixture(now)
+    },
+    {
+        id: "manual.documented.plan",
+        connector: "manual",
+        docsUrl: null,
+        reviewedAt: FIXTURE_REVIEWED_AT,
+        sourceStatus: "official",
+        note: "OpenLimiter owns this format, so our own documentation is the source.",
+        expectedMeters: 1,
+        build: (now) => manualFixture(now)
+    }
+];
+function captureWindow(value, capturedAtSeconds) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return null;
+    const input = value;
+    const percent = input["used_percentage"];
+    const resets = input["resets_at"];
+    if (typeof percent !== "number" || !Number.isFinite(percent))
+        return null;
+    if (typeof resets !== "number" || !Number.isFinite(resets))
+        return null;
+    return {
+        usedPercentage: Math.round(percent * 10) / 10,
+        resetsInSeconds: Math.round(resets - capturedAtSeconds)
+    };
+}
+/**
+ * The capture harness.
+ *
+ * Run it on a real statusline payload on a machine with a Pro or Max account,
+ * print the result, and paste that object into `claudeSanitizedLive` below. It
+ * is the only supported way a live Claude fixture enters this repository, and
+ * it is deliberately lossy.
+ */
+export function sanitizeClaudeStatusline(payload, capturedAtSeconds) {
+    if (typeof payload !== "object" || payload === null || Array.isArray(payload)) {
+        return null;
+    }
+    const root = payload;
+    const limits = root["rate_limits"];
+    if (typeof limits !== "object" || limits === null || Array.isArray(limits))
+        return null;
+    const windows = limits;
+    const fiveHour = captureWindow(windows["five_hour"], capturedAtSeconds);
+    const sevenDay = captureWindow(windows["seven_day"], capturedAtSeconds);
+    if (fiveHour === null && sevenDay === null)
+        return null;
+    const version = root["version"];
+    return {
+        fiveHour,
+        sevenDay,
+        claudeCodeVersion: typeof version === "string" && version.length <= 32
+            ? version
+            : null
+    };
+}
+/** Turn a scrubbed capture back into a payload a parser can be run against. */
+export function claudeCapturePayload(capture, now = FIXTURE_NOW) {
+    const limits = {};
+    if (capture.fiveHour !== null) {
+        limits["five_hour"] = {
+            used_percentage: capture.fiveHour.usedPercentage,
+            resets_at: epochOffset(now, capture.fiveHour.resetsInSeconds)
+        };
+    }
+    if (capture.sevenDay !== null) {
+        limits["seven_day"] = {
+            used_percentage: capture.sevenDay.usedPercentage,
+            resets_at: epochOffset(now, capture.sevenDay.resetsInSeconds)
+        };
+    }
+    return { rate_limits: limits };
+}
+/**
+ * PENDING CAPTURE.
+ *
+ * There is no live Claude capture in this repository. Producing one needs a
+ * machine signed into a Pro or Max account, running Claude Code, after the
+ * first API response of a session, and no such capture has been taken.
+ *
+ * Inventing one would rebuild exactly the fault the audit found, so this entry
+ * exists to make the gap loud: every test that would use it skips and says why,
+ * and the provider stays UNVERIFIED until the capture lands here through
+ * `sanitizeClaudeStatusline` above.
+ */
+export const claudeSanitizedLive = {
+    id: "claude.live.pending",
+    connector: "claude",
+    status: "pending_capture",
+    capturedAt: null,
+    providerVersion: null,
+    skipReason: "PENDING CAPTURE: no sanitized live Claude Code statusline payload " +
+        "exists yet. Capture one on a Pro or Max account with " +
+        "sanitizeClaudeStatusline, paste the result here, then remove this reason.",
+    expectedMeters: 0,
+    build: () => null
+};
+/**
+ * PENDING CAPTURE: Codex usage.
+ *
+ * The REQUEST contract for this reader is known, reproducible and recorded, in
+ * `provider_specs/openai/codex.yaml` and in the endpoint constants in
+ * `apps/desktop/src-tauri/src/net.rs`: the method, the address, the
+ * authentication, the fixed headers and the behaviour of an expired login were
+ * all taken from a reader that ran against a real account on 2026-08-07.
+ *
+ * The RESPONSE is a different question, and it is open. No sanitized response
+ * from that account has been committed here, and the shape the shipped parser
+ * reads was observed in the original prototype rather than captured through
+ * this code. Writing a payload from memory to make this slot look full would
+ * rebuild exactly the fault the fixture classes exist to prevent, so the slot
+ * stays empty and loud: every test that would use it skips and says why, the
+ * provider stays UNVERIFIED, and the registry validator reports the gap on
+ * every run and fails outright under --require-captures.
+ */
+export const codexSanitizedLive = {
+    id: "codex.sanitized_live.usage",
+    connector: "codex",
+    status: "captured",
+    capturedAt: "2026-09-01",
+    providerVersion: "codex-cli 0.152.0",
+    skipReason: null,
+    expectedMeters: 1,
+    /* Reduced by scripts/sanitize-capture.mjs. Numbers and closed vocabulary
+       words only: every other field of the real response was discarded rather
+       than redacted, so nothing identifying can be present even in principle.
+       Resets are seconds from capture, never instants, so this replays against
+       any clock and dates nobody's working day. */
+    capture: {
+        "usedPercent": 20,
+        "resetsInSeconds": 448881,
+        "limitWindowSeconds": 604800
+    },
+    build: (now) => rebuildCodexCapture(codexSanitizedLive.capture, now)
+};
+/**
+ * PENDING CAPTURE: Antigravity quota summary.
+ *
+ * Same standing as the Codex slot above. The request is recorded, including the
+ * detail that the endpoint answers 403 to a valid token when the user agent
+ * header is missing, which was measured on 2026-08-07. No sanitized response
+ * has been committed, so nothing here claims to know the shape of one.
+ */
+export const antigravitySanitizedLive = {
+    id: "antigravity.sanitized_live.quota",
+    connector: "antigravity",
+    status: "captured",
+    capturedAt: "2026-09-01",
+    providerVersion: "antigravity/cli/1.1.15",
+    skipReason: null,
+    expectedMeters: 2,
+    /* Reduced by scripts/sanitize-capture.mjs. Numbers and closed vocabulary
+       words only: every other field of the real response was discarded rather
+       than redacted, so nothing identifying can be present even in principle.
+       Resets are seconds from capture, never instants, so this replays against
+       any clock and dates nobody's working day. */
+    capture: {
+        "groups": [
+            {
+                "buckets": [
+                    {
+                        "poolPrefix": "gemini",
+                        "window": "weekly",
+                        "remainingFraction": 0.9867396,
+                        "resetsInSeconds": 524780
+                    },
+                    {
+                        "poolPrefix": "gemini",
+                        "window": "5h",
+                        "remainingFraction": 0.9561311,
+                        "resetsInSeconds": 9265
+                    }
+                ]
+            },
+            {
+                "buckets": [
+                    {
+                        "poolPrefix": "3p",
+                        "window": "weekly",
+                        "remainingFraction": 1,
+                        "resetsInSeconds": 604461
+                    },
+                    {
+                        "poolPrefix": "3p",
+                        "window": "5h",
+                        "remainingFraction": 1,
+                        "resetsInSeconds": 17661
+                    }
+                ]
+            }
+        ]
+    },
+    build: (now) => rebuildAntigravityCapture(antigravitySanitizedLive.capture, now)
+};
+/**
+ * PENDING CAPTURE: OpenCode workspace usage.
+ *
+ * The weakest evidence of the three, and permanently so. There is no interface
+ * to capture: the meters exist only inside the html of a logged in page, so any
+ * capture is a capture of a layout. That is why this provider's labels do not
+ * improve when the slot is filled: browser-session, authenticated-scrape,
+ * automationRisk high and UNVERIFIED are properties of the method, not of how
+ * much evidence has been gathered about it.
+ */
+export const opencodeSanitizedLive = {
+    id: "opencode.sanitized_live.usage",
+    connector: "opencode",
+    status: "pending_capture",
+    capturedAt: null,
+    providerVersion: null,
+    skipReason: "PENDING CAPTURE: no sanitized live OpenCode workspace page " +
+        "exists yet. Capture one on a real account, reduce it to the window " +
+        "labels, percentages and remaining durations only, paste the result " +
+        "here, then remove this reason. The honesty labels do not change when " +
+        "it lands.",
+    expectedMeters: 0,
+    build: () => null
+};
+export const grokSanitizedLive = {
+    id: "grok.live.pending",
+    connector: "grok",
+    status: "pending_capture",
+    capturedAt: null,
+    providerVersion: null,
+    skipReason: "PENDING CAPTURE: the fixture comes from official source code, not a live Grok account.",
+    expectedMeters: 0,
+    build: () => null
+};
+export const kimiSanitizedLive = {
+    id: "kimi.live.pending",
+    connector: "kimi",
+    status: "pending_capture",
+    capturedAt: null,
+    providerVersion: null,
+    skipReason: "PENDING CAPTURE: the fixture comes from official source code, not a live Kimi account.",
+    expectedMeters: 0,
+    build: () => null
+};
+/* ------------------------------------------------------------------ *
+ * Rebuilding a payload from a reduced capture
+ *
+ * A capture holds numbers. A parser wants the provider's own shape. These turn
+ * one into the other, against a supplied clock, so a capture taken months ago
+ * still produces a payload whose resets are in the future. They are the only
+ * readers of the `capture` field, and they are written to fail closed: a
+ * capture they cannot read rebuilds as null, which every parser refuses.
+ * ------------------------------------------------------------------ */
+function captureRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : null;
+}
+function captureNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+export function rebuildCodexCapture(capture, now) {
+    const reduced = captureRecord(capture);
+    const percent = captureNumber(reduced?.["usedPercent"]);
+    const resetsIn = captureNumber(reduced?.["resetsInSeconds"]);
+    if (percent === null || resetsIn === null)
+        return null;
+    const length = captureNumber(reduced?.["limitWindowSeconds"]);
+    const primary = {
+        used_percent: percent,
+        reset_at: epochOffset(now, resetsIn)
+    };
+    if (length !== null)
+        primary["limit_window_seconds"] = length;
+    return { rate_limit: { primary_window: primary } };
+}
+export function rebuildAntigravityCapture(capture, now) {
+    const reduced = captureRecord(capture);
+    const groups = reduced?.["groups"];
+    if (!Array.isArray(groups))
+        return null;
+    const rebuilt = [];
+    for (const entry of groups) {
+        const group = captureRecord(entry);
+        const buckets = group?.["buckets"];
+        if (!Array.isArray(buckets))
+            return null;
+        const rebuiltBuckets = [];
+        for (const rawBucket of buckets) {
+            const bucket = captureRecord(rawBucket);
+            const prefix = bucket?.["poolPrefix"];
+            const window = bucket?.["window"];
+            const fraction = captureNumber(bucket?.["remainingFraction"]);
+            const resetsIn = captureNumber(bucket?.["resetsInSeconds"]);
+            if (typeof prefix !== "string" || typeof window !== "string")
+                return null;
+            if (fraction === null || resetsIn === null)
+                return null;
+            rebuiltBuckets.push({
+                /* The id's tail named a model and a plan and was discarded, so a
+                   neutral one is synthesised from the prefix the parser matches on. */
+                bucketId: prefix + "-captured",
+                window,
+                remainingFraction: fraction,
+                resetTime: rfc3339Offset(now, resetsIn)
+            });
+        }
+        rebuilt.push({ buckets: rebuiltBuckets });
+    }
+    return { groups: rebuilt };
+}
+function captureDurationWords(seconds) {
+    const days = Math.floor(seconds / 86_400);
+    const hours = Math.floor((seconds % 86_400) / 3_600);
+    const minutes = Math.floor((seconds % 3_600) / 60);
+    const parts = [];
+    if (days > 0)
+        parts.push(String(days) + (days === 1 ? " day" : " days"));
+    if (hours > 0)
+        parts.push(String(hours) + (hours === 1 ? " hour" : " hours"));
+    if (parts.length === 0 && minutes > 0) {
+        parts.push(String(minutes) + (minutes === 1 ? " minute" : " minutes"));
+    }
+    return parts.join(" ");
+}
+export function rebuildOpencodeCapture(capture, now) {
+    const reduced = captureRecord(capture);
+    const windows = reduced?.["windows"];
+    if (!Array.isArray(windows) || windows.length !== 3)
+        return null;
+    const byLabel = new Map();
+    for (const entry of windows) {
+        const window = captureRecord(entry);
+        const label = window?.["label"];
+        const percent = captureNumber(window?.["percent"]);
+        if (typeof label !== "string" || percent === null)
+            return null;
+        const resetsIn = captureNumber(window?.["resetsInSeconds"]);
+        byLabel.set(label, {
+            percent,
+            resetsIn: resetsIn === null ? null : captureDurationWords(resetsIn)
+        });
+    }
+    const rolling = byLabel.get("Rolling Usage");
+    const weekly = byLabel.get("Weekly Usage");
+    const monthly = byLabel.get("Monthly Usage");
+    if (rolling === undefined || weekly === undefined || monthly === undefined)
+        return null;
+    return opencodePage(rolling, weekly, monthly, now);
+}
+export const sanitizedLiveFixtures = [
+    claudeSanitizedLive,
+    codexSanitizedLive,
+    antigravitySanitizedLive,
+    opencodeSanitizedLive,
+    grokSanitizedLive,
+    kimiSanitizedLive
+];
+function claudeWindows(five, seven) {
+    const limits = {};
+    if (five !== undefined)
+        limits["five_hour"] = five;
+    if (seven !== undefined)
+        limits["seven_day"] = seven;
+    return { rate_limits: limits };
+}
+function goodFiveHour(now) {
+    return { used_percentage: 42, resets_at: epochOffset(now, FIVE_HOURS) };
+}
+function goodSevenDay(now) {
+    return { used_percentage: 64, resets_at: epochOffset(now, SEVEN_DAYS) };
+}
+/**
+ * The Claude epoch edge cases.
+ *
+ * Every one of these is a way a reset instant can arrive wrong, and each has a
+ * single correct answer. The 2038 entry is the odd one out and is expected to
+ * PASS: it is here to prove nothing in the conversion truncates to 32 bits.
+ */
+const claudeMalformed = [
+    {
+        id: "claude.malformed.epoch_milliseconds",
+        connector: "claude",
+        reason: "resets_at in milliseconds instead of seconds",
+        expectedMeters: 0,
+        build: (now) => claudeWindows({ used_percentage: 42, resets_at: epochOffset(now, FIVE_HOURS) * 1_000 }, undefined)
+    },
+    {
+        id: "claude.malformed.epoch_negative",
+        connector: "claude",
+        reason: "negative resets_at",
+        expectedMeters: 0,
+        build: (now) => claudeWindows({ used_percentage: 42, resets_at: -1 }, undefined)
+    },
+    {
+        id: "claude.malformed.epoch_zero",
+        connector: "claude",
+        reason: "resets_at of zero, which is the epoch itself and long past",
+        expectedMeters: 0,
+        build: (now) => claudeWindows({ used_percentage: 42, resets_at: 0 }, undefined)
+    },
+    {
+        id: "claude.edge.epoch_string",
+        connector: "claude",
+        reason: "resets_at as the digits of an epoch in quotes, which is a JSON " +
+            "writer quoting its numbers rather than a different instant",
+        expectedMeters: 1,
+        build: (now) => claudeWindows({ used_percentage: 42, resets_at: String(epochOffset(now, FIVE_HOURS)) }, undefined)
+    },
+    {
+        id: "claude.edge.reset_iso_string",
+        connector: "claude",
+        reason: "resets_at as an ISO string, which the usage document and the " +
+            "model_scoped list both state, so it is a second encoding rather than drift",
+        expectedMeters: 1,
+        build: (now) => claudeWindows({ used_percentage: 42, resets_at: offset(now, FIVE_HOURS) }, undefined)
+    },
+    {
+        id: "claude.edge.utilization_field",
+        connector: "claude",
+        reason: "utilization rather than used_percentage, which is what the " +
+            "api/oauth/usage document states for the same reading",
+        expectedMeters: 1,
+        build: (now) => claudeWindows({ utilization: 42, resets_at: epochOffset(now, FIVE_HOURS) }, undefined)
+    },
+    {
+        id: "claude.malformed.epoch_expired",
+        connector: "claude",
+        reason: "a reset that already happened",
+        expectedMeters: 0,
+        build: (now) => claudeWindows({ used_percentage: 42, resets_at: epochOffset(now, -FIVE_HOURS) }, undefined)
+    },
+    {
+        id: "claude.malformed.epoch_year_2038",
+        connector: "claude",
+        reason: "a five hour window claiming to reset in 2038, which is not a wait " +
+            "but a corrupt field",
+        expectedMeters: 0,
+        build: () => ({
+            rate_limits: {
+                five_hour: { used_percentage: 42, resets_at: 2_147_483_648 }
+            }
+        })
+    },
+    {
+        id: "claude.malformed.epoch_just_past_horizon",
+        connector: "claude",
+        reason: "a five hour reset one second past the plausible horizon",
+        expectedMeters: 0,
+        build: (now) => claudeWindows({
+            used_percentage: 42,
+            resets_at: epochOffset(now, FIVE_HOURS * 2 + 3_600 + 1)
+        }, undefined)
+    },
+    {
+        id: "claude.edge.epoch_at_horizon",
+        connector: "claude",
+        reason: "a five hour reset exactly at the plausible horizon, which stands",
+        expectedMeters: 1,
+        build: (now) => claudeWindows({ used_percentage: 42, resets_at: epochOffset(now, FIVE_HOURS * 2 + 3_600) }, undefined)
+    },
+    {
+        id: "claude.edge.horizon_is_per_window",
+        connector: "claude",
+        reason: "a reset three days out, implausible for five hours and fine for " +
+            "seven days, so exactly one window survives",
+        expectedMeters: 1,
+        build: (now) => claudeWindows({ used_percentage: 42, resets_at: epochOffset(now, ONE_DAY * 3) }, { used_percentage: 64, resets_at: epochOffset(now, ONE_DAY * 3) })
+    },
+    {
+        id: "claude.edge.missing_five_hour",
+        connector: "claude",
+        reason: "only the seven day window present, which is one complete answer",
+        expectedMeters: 1,
+        build: (now) => claudeWindows(undefined, goodSevenDay(now))
+    },
+    {
+        id: "claude.edge.missing_seven_day",
+        connector: "claude",
+        reason: "only the five hour window present, which is one complete answer",
+        expectedMeters: 1,
+        build: (now) => claudeWindows(goodFiveHour(now), undefined)
+    },
+    {
+        id: "claude.edge.missing_both_windows",
+        connector: "claude",
+        reason: "rate_limits present and empty, which is unknown rather than zero",
+        expectedMeters: 0,
+        build: (now) => claudeWindows(undefined, undefined)
+    },
+    {
+        id: "claude.edge.rate_limits_absent",
+        connector: "claude",
+        reason: "no rate_limits at all, the ordinary free account payload",
+        expectedMeters: 0,
+        build: () => ({ session_id: "synthetic", version: "0.0.0-synthetic" })
+    },
+    {
+        id: "claude.edge.unknown_window_alongside",
+        connector: "claude",
+        reason: "an undocumented three_hour window, read under a code built from " +
+            "its own key rather than dropped, alongside the two documented windows",
+        expectedMeters: 3,
+        build: (now) => ({
+            rate_limits: {
+                five_hour: goodFiveHour(now),
+                seven_day: goodSevenDay(now),
+                three_hour: { used_percentage: 10, resets_at: epochOffset(now, 10_800) }
+            }
+        })
+    },
+    {
+        id: "claude.edge.unknown_window_only",
+        connector: "claude",
+        reason: "nothing but an undocumented window, which is still one real " +
+            "reading the provider stated",
+        expectedMeters: 1,
+        build: (now) => ({
+            rate_limits: {
+                three_hour: { used_percentage: 10, resets_at: epochOffset(now, 10_800) }
+            }
+        })
+    },
+    {
+        id: "claude.malformed.window_as_array",
+        connector: "claude",
+        reason: "a window that is an array",
+        expectedMeters: 0,
+        build: (now) => claudeWindows([42], undefined)
+    },
+    {
+        id: "claude.malformed.rate_limits_as_array",
+        connector: "claude",
+        reason: "rate_limits that is an array",
+        expectedMeters: 0,
+        build: () => ({ rate_limits: [] })
+    }
+];
+const genericIds = [
+    "claude",
+    "openrouter",
+    "codex",
+    "antigravity",
+    "opencode",
+    "grok",
+    "kimi",
+    "manual"
+];
+/**
+ * The shapes every parser must refuse, whatever provider it reads.
+ *
+ * Generated per connector rather than written out six times, so a new
+ * connector cannot be added without inheriting the whole hostile set.
+ */
+const genericMalformed = genericIds.flatMap((connector) => [
+    {
+        id: connector + ".malformed.undefined",
+        connector,
+        reason: "no payload at all",
+        expectedMeters: 0,
+        build: () => undefined
+    },
+    {
+        id: connector + ".malformed.empty_object",
+        connector,
+        reason: "an empty object",
+        expectedMeters: 0,
+        build: () => ({})
+    },
+    {
+        id: connector + ".malformed.array_root",
+        connector,
+        reason: "an array where an object belongs",
+        expectedMeters: 0,
+        build: () => []
+    },
+    {
+        id: connector + ".malformed.string_root",
+        connector,
+        reason: "a string, which is what an HTML error page arrives as",
+        expectedMeters: 0,
+        build: () => "<!doctype html><title>502 Bad Gateway</title>"
+    },
+    {
+        id: connector + ".malformed.hostile_root",
+        connector,
+        reason: "prompt injection text and an enormous number at the root",
+        expectedMeters: 0,
+        build: () => ({ ...hostileFixture })
+    }
+]);
+export const malformedFixtures = [
+    ...claudeMalformed,
+    ...genericMalformed
+];
+/** Every fixture class in one place, for a test that wants to sweep them all. */
+export const fixtureClasses = {
+    documented: documentedFixtures,
+    sanitizedLive: sanitizedLiveFixtures,
+    malformed: malformedFixtures
+};
 //# sourceMappingURL=fixtures.js.map