@openlimiter/connectors 0.1.0 → 0.4.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,59 +30,198 @@ 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";
+/** 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)
             }
         }
     };
 }
+/**
+ * A credit plan with real money in it, so the dollar line has something to say.
+ *
+ * Twelve dollars and change out of twenty is 62.35 percent, which also puts the
+ * one credit based provider in the middle pressure band. Both numbers are
+ * invented for this file and belong to no account.
+ */
 export function openrouterFixture() {
     return {
         data: {
-            total_credits: 100,
-            total_usage: 37
+            total_credits: 20,
+            total_usage: 12.47
         }
     };
 }
+/**
+ * The one fixture in the orange band.
+ *
+ * Eighty four percent is deliberate, the same way ninety two is below. The
+ * meter colour scale has four bands and a demo that never reaches one of them
+ * cannot teach it, so this fixture sits between the engine's NEAR_CAP threshold
+ * at 80 and the visual red at 90, which is the band that exists to show the gap
+ * between the two.
+ *
+ * Eighty four also keeps the demo's routing advice where it was. The policy
+ * stops recommending a provider at 80, so Codex drops out of the running here,
+ * and the lowest reading still under that line is Antigravity at 28. The demo
+ * therefore still says PREFER ANTIGRAVITY, exactly as it did when this fixture
+ * read 51.
+ */
 export function codexFixture(now = FIXTURE_NOW) {
     return {
-        rate_limits: {
+        rate_limit: {
             primary_window: {
-                used_percent: 51,
-                reset_at: offset(now, FIVE_HOURS)
+                used_percent: 84,
+                reset_at: epochOffset(now, FIVE_HOURS),
+                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)
+                    }
+                ]
+            }
+        ]
     };
 }
+/**
+ * The one fixture in the red band.
+ *
+ * Ninety two percent is deliberate. A demo where nothing is ever in trouble
+ * teaches nobody what trouble looks like, so one provider sits above the
+ * critical threshold and every surface has to draw it. With Codex at 84 above,
+ * the demo set now lands one meter in each of the four bands.
+ */
 export function opencodeFixture(now = FIXTURE_NOW) {
-    return {
-        usage: {
-            percent: 73,
-            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 {
@@ -80,4 +238,627 @@ 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: 1,
+        build: (now) => antigravityFixture(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: 1,
+        build: (now) => opencodeFixture(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: "pending_capture",
+    capturedAt: null,
+    providerVersion: null,
+    skipReason: "PENDING CAPTURE: no sanitized live Codex usage response exists " +
+        "yet. The request contract is recorded; the response is not. Capture one " +
+        "on a real account, reduce it to numbers and window lengths only, paste " +
+        "the result here, then remove this reason.",
+    expectedMeters: 0,
+    build: () => null
+};
+/**
+ * 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: "pending_capture",
+    capturedAt: null,
+    providerVersion: null,
+    skipReason: "PENDING CAPTURE: no sanitized live Antigravity quota summary " +
+        "exists yet. The request contract is recorded; the response is not. " +
+        "Capture one on a real account, reduce it to fractions and window " +
+        "lengths only, paste the result here, then remove this reason.",
+    expectedMeters: 0,
+    build: () => null
+};
+/**
+ * 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
+};
+/* ------------------------------------------------------------------ *
+ * 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
+];
+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.malformed.epoch_string",
+        connector: "claude",
+        reason: "resets_at as a string rather than a number",
+        expectedMeters: 0,
+        build: (now) => claudeWindows({ used_percentage: 42, resets_at: String(epochOffset(now, FIVE_HOURS)) }, undefined)
+    },
+    {
+        id: "claude.malformed.epoch_iso_string",
+        connector: "claude",
+        reason: "resets_at as the ISO string our old invented shape used",
+        expectedMeters: 0,
+        build: (now) => claudeWindows({ used_percentage: 42, resets_at: offset(now, FIVE_HOURS) }, undefined)
+    },
+    {
+        id: "claude.malformed.legacy_utilization_field",
+        connector: "claude",
+        reason: "the invented utilization field, which no release is known to emit",
+        expectedMeters: 0,
+        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, dropped without disturbing the rest",
+        expectedMeters: 2,
+        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 unknown",
+        expectedMeters: 0,
+        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",
+    "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