@tokenbuddy/tokenbuddy 1.0.36 → 1.0.38

package/tests/route-failover.test.ts

@@ -1,222 +0,0 @@
-import { CreditTracker } from "../src/credit-tracker.js";
-import { ModelIndex } from "../src/model-index.js";
-import { PrewarmCache } from "../src/prewarm-cache.js";
-import { RouteFailover, type DecideContext } from "../src/route-failover.js";
-import { SellerPool } from "../src/seller-pool.js";
-import type { RegistrySeller } from "../src/seller-catalog.js";
-
-function makeSeller(overrides: Partial<RegistrySeller> & { id: string; models?: string[] }): RegistrySeller {
-  return {
-    id: overrides.id,
-    name: overrides.name ?? overrides.id,
-    url: overrides.url ?? `https://${overrides.id}.example.com`,
-    supportedProtocols: overrides.supportedProtocols ?? ["chat_completions"],
-    paymentMethods: overrides.paymentMethods ?? ["clawtip"],
-    models: overrides.models
-  };
-}
-
-function buildHarness(seed: { id: string; healthScore?: number }[] = []) {
-  const sellers: RegistrySeller[] = seed.map((s) => makeSeller({ id: s.id, models: ["gpt-4o"] }));
-  const index = new ModelIndex();
-  index.rebuild(sellers, { registryVersion: 1, defaultSellerId: seed[0]?.id });
-  const cache = new PrewarmCache();
-  cache.commitWarm({
-    modelId: "gpt-4o",
-    protocol: "chat_completions",
-    paymentMethod: "clawtip",
-    candidates: seed.map((s) => ({
-      sellerId: s.id,
-      url: `https://${s.id}.example.com`,
-      healthScore: s.healthScore ?? 80
-    }))
-  });
-  const credit = new CreditTracker();
-  const pool = new SellerPool({ modelIndex: index, cache, creditTracker: credit });
-  pool.sync();
-  const failover = new RouteFailover({ pool, creditTracker: credit });
-  return { index, cache, credit, pool, failover, sellers };
-}
-
-describe("RouteFailover", () => {
-  test("pickNext returns the highest-scoring candidate from the pool", () => {
-    const { failover } = buildHarness([{ id: "s1", healthScore: 50 }, { id: "s2", healthScore: 90 }, { id: "s3", healthScore: 70 }]);
-    const next = failover.pickNext("gpt-4o", "chat_completions", "clawtip");
-    expect(next?.sellerId).toBe("s2");
-  });
-
-  test("pickNext returns undefined when the pool is exhausted", () => {
-    const index = new ModelIndex();
-    index.rebuild([], { registryVersion: 1 });
-    const cache = new PrewarmCache();
-    const credit = new CreditTracker();
-    const pool = new SellerPool({ modelIndex: index, cache, creditTracker: credit });
-    pool.sync();
-    const failover = new RouteFailover({ pool, creditTracker: credit });
-    expect(failover.pickNext("gpt-4o", "chat_completions", "clawtip")).toBeUndefined();
-  });
-
-  test("decide on hard_4xx immediately returns failover_next and never retries", () => {
-    const { failover, credit } = buildHarness([{ id: "s1" }]);
-    credit.recordPurchase("s1", 1_000_000, 800_000);
-    const context: DecideContext = {
-      sellerId: "s1",
-      status: 404,
-      errorKind: "hard_4xx",
-      errorMessage: "model not found",
-      attempt: 0
-    };
-    const decision = failover.decide(context, 1);
-    expect(decision.action).toBe("failover_next");
-    expect(decision.reason).toBe("hard_failure:hard_4xx");
-    expect(decision.freshPurchase).toBe(true);
-    // Hard failure transfers leftover to wasted.
-    expect(decision.wastedCreditMicros).toBeGreaterThan(0);
-  });
-
-  test("decide on auth_invalid opens the circuit and surfaces failover", () => {
-    const { failover, pool } = buildHarness([{ id: "s1" }]);
-    const context: DecideContext = {
-      sellerId: "s1",
-      status: 401,
-      errorKind: "auth_invalid",
-      errorMessage: "token_invalid",
-      attempt: 0
-    };
-    const decision = failover.decide(context, 1);
-    expect(decision.action).toBe("failover_next");
-    expect(pool.snapshot()[0].circuit).toBe("open");
-  });
-
-  test("decide on soft_5xx inside fresh-purchase window retries the same seller with jitter", () => {
-    const { failover, credit } = buildHarness([{ id: "s1" }]);
-    credit.recordPurchase("s1", 1_000_000, 1_000_000);
-    const decision = failover.decide(
-      { sellerId: "s1", status: 503, errorKind: "soft_5xx", errorMessage: "upstream", attempt: 0 },
-      1
-    );
-    expect(decision.action).toBe("retry_same_seller");
-    expect(decision.retryDelayMs).toBeGreaterThanOrEqual(100);
-    expect(decision.retryDelayMs).toBeLessThanOrEqual(400);
-    expect(decision.freshPurchase).toBe(true);
-    expect(decision.reason).toBe("soft_failure_fresh_purchase_window");
-  });
-
-  test("decide on busy_capacity fails over without retrying or opening the circuit", () => {
-    const { failover, credit, pool } = buildHarness([{ id: "s1" }, { id: "s2" }]);
-    credit.recordPurchase("s1", 1_000_000, 1_000_000);
-    const decision = failover.decide(
-      { sellerId: "s1", status: 429, errorKind: "busy_capacity", errorMessage: "capacity full", attempt: 0 },
-      2
-    );
-
-    expect(decision.action).toBe("failover_next");
-    expect(decision.reason).toBe("busy_capacity");
-    const entry = pool.snapshot().find((candidate) => candidate.sellerId === "s1");
-    expect(entry?.circuit).toBe("closed");
-    expect(entry?.consecutiveFailures).toBe(0);
-    expect(entry?.capacityBlockedUntil).toBeGreaterThan(Date.now());
-  });
-
-  test("decide on soft_5xx after exhausting retries returns failover_next", () => {
-    const { failover, credit } = buildHarness([{ id: "s1" }]);
-    credit.recordPurchase("s1", 1_000_000, 1_000_000);
-    const decision = failover.decide(
-      { sellerId: "s1", status: 503, errorKind: "soft_5xx", errorMessage: "upstream", attempt: 2 },
-      1
-    );
-    expect(decision.action).toBe("failover_next");
-    expect(decision.reason).toBe("soft_failure_exhausted_retries");
-  });
-
-  test("decide on soft_5xx outside the fresh-purchase window still allows the first retry", () => {
-    const { failover, credit } = buildHarness([{ id: "s1" }]);
-    // Record a purchase, then spend it past the threshold so the window exits.
-    credit.recordPurchase("s1", 1_000_000, 1_000_000);
-    credit.recordSpend("s1", 100_000);
-    const decision = failover.decide(
-      { sellerId: "s1", status: 503, errorKind: "soft_5xx", errorMessage: "upstream", attempt: 0 },
-      1
-    );
-    expect(decision.action).toBe("retry_same_seller");
-    expect(decision.freshPurchase).toBe(false);
-    expect(decision.reason).toBe("soft_failure_retry");
-  });
-
-  test("decide on deadline uses the soft-error path", () => {
-    const { failover, credit } = buildHarness([{ id: "s1" }]);
-    credit.recordPurchase("s1", 1_000_000, 1_000_000);
-    const decision = failover.decide(
-      { sellerId: "s1", errorKind: "deadline", errorMessage: "buyer timeout", attempt: 0 },
-      1
-    );
-    expect(decision.action).toBe("retry_same_seller");
-    expect(decision.freshPurchase).toBe(true);
-  });
-
-  test("decide on purchase_failed fails over without scheduling a soft retry", () => {
-    const { failover, credit } = buildHarness([{ id: "s1" }, { id: "s2" }]);
-    credit.recordPurchase("s1", 1_000_000, 750_000);
-    const decision = failover.decide(
-      { sellerId: "s1", errorKind: "purchase_failed", errorMessage: "purchase create failed", attempt: 0 },
-      2
-    );
-
-    expect(decision.action).toBe("failover_next");
-    expect(decision.reason).toBe("purchase_failed");
-    expect(decision.wastedCreditMicros).toBe(750_000);
-  });
-
-  test("budgetExceeded flag is set when the per-minute purchase budget is exhausted", () => {
-    const { failover, credit } = buildHarness([{ id: "s1" }]);
-    // Burn through the per-minute budget.
-    credit.recordPurchase("s1", 100, 100);
-    credit.recordPurchase("s2" in credit.summary().perSeller ? "s2" : "s1", 100, 100);
-    credit.recordPurchase("s1", 100, 100);
-    credit.recordPurchase("s1", 100, 100);
-    const decision = failover.decide(
-      { sellerId: "s1", errorKind: "soft_5xx", attempt: 0 },
-      1
-    );
-    expect(decision.budgetExceeded).toBe(true);
-  });
-
-  test("recordSuccess resets failure counters and reports to the credit tracker", () => {
-    const { failover, credit, pool } = buildHarness([{ id: "s1" }]);
-    credit.recordPurchase("s1", 1_000_000, 1_000_000);
-    failover.decide(
-      { sellerId: "s1", errorKind: "soft_5xx", attempt: 0 },
-      1
-    );
-    failover.decide(
-      { sellerId: "s1", errorKind: "soft_5xx", attempt: 1 },
-      1
-    );
-    failover.recordSuccess("s1", 750_000);
-    const entry = pool.snapshot()[0];
-    expect(entry.consecutiveFailures).toBe(0);
-    expect(credit.getEntry("s1")?.currentBalanceMicros).toBe(750_000);
-  });
-
-  test("shouldAbort returns true when no more candidates are available", () => {
-    const { failover } = buildHarness([{ id: "s1" }]);
-    expect(failover.shouldAbort(1, false)).toBe(true);
-    expect(failover.shouldAbort(1, true)).toBe(false);
-  });
-
-  test("canAutoPurchase mirrors the credit tracker budget", () => {
-    const { failover, credit } = buildHarness([{ id: "s1" }]);
-    expect(failover.canAutoPurchase()).toBe(true);
-    credit.recordPurchase("s1", 100, 100);
-    credit.recordPurchase("s1", 100, 100);
-    credit.recordPurchase("s1", 100, 100);
-    expect(failover.canAutoPurchase()).toBe(false);
-  });
-
-  test("wastedMicrosFor returns the latest known balance for a seller", () => {
-    const { failover, credit } = buildHarness([{ id: "s1" }]);
-    expect(failover.wastedMicrosFor("s1")).toBe(0);
-    credit.recordPurchase("s1", 1_000_000, 500_000);
-    expect(failover.wastedMicrosFor("s1")).toBe(500_000);
-  });
-});

package/tests/seller-catalog-413.test.ts

@@ -1,120 +0,0 @@
-import * as crypto from "crypto";
-import { RegistryTooLargeError, fetchSellerRegistry, fetchSellerRegistryWithTrust } from "../src/seller-catalog.js";
-import { DEFAULT_SELLER_REGISTRY_URL } from "../src/registry-trust.js";
-
-/**
- * v1.2 §18.9: registry-too-large fallback. The bootstrap returns 413
- * with a structured body when the serialized registry exceeds 1MB; the
- * buyer must surface this as a typed error so the daemon can fall back
- * to the last-known snapshot.
- */
-describe("RegistryTooLargeError + fetchSellerRegistry 413", () => {
-  const originalFetch = globalThis.fetch;
-
-  afterEach(() => {
-    globalThis.fetch = originalFetch;
-  });
-
-  function mockJsonResponse(status: number, body: unknown): Response {
-    return new Response(JSON.stringify(body), {
-      status,
-      headers: { "Content-Type": "application/json" }
-    });
-  }
-
-  test("fetchSellerRegistry throws RegistryTooLargeError on HTTP 413 with the bootstrap's payload", async () => {
-    globalThis.fetch = (async () =>
-      mockJsonResponse(413, {
-        error: "registry_too_large",
-        sizeBytes: 1_500_000,
-        sellerCount: 2_400,
-        maxBytes: 1_000_000
-      })) as unknown as typeof globalThis.fetch;
-    await expect(
-      fetchSellerRegistry("https://bootstrap.example/registry/sellers")
-    ).rejects.toMatchObject({
-      name: "RegistryTooLargeError",
-      status: 413,
-      sizeBytes: 1_500_000,
-      sellerCount: 2_400,
-      maxBytes: 1_000_000
-    });
-  });
-
-  test("fetchSellerRegistry still surfaces generic non-2xx as plain errors", async () => {
-    globalThis.fetch = (async () => mockJsonResponse(500, { error: "internal" })) as unknown as typeof globalThis.fetch;
-    await expect(
-      fetchSellerRegistry("https://bootstrap.example/registry/sellers")
-    ).rejects.toThrow(/registry returned 500/);
-  });
-
-  test("fetchSellerRegistry rejects the default registry when signature is missing", async () => {
-    globalThis.fetch = (async (url: string | URL | Request) => {
-      const href = String(url);
-      if (href.endsWith("/registry.json")) {
-        return mockJsonResponse(200, { version: 1, sellers: [] });
-      }
-      if (href.endsWith("/registry.sig")) {
-        return mockJsonResponse(404, { error: "missing" });
-      }
-      throw new Error(`unexpected fetch ${href}`);
-    }) as unknown as typeof globalThis.fetch;
-
-    await expect(fetchSellerRegistry(DEFAULT_SELLER_REGISTRY_URL)).rejects.toThrow("registry signature returned 404");
-  });
-
-  test("fetchSellerRegistry can explicitly allow unsigned registry for local development", async () => {
-    const previous = process.env.TB_PROXYD_ALLOW_UNSIGNED_REGISTRY;
-    process.env.TB_PROXYD_ALLOW_UNSIGNED_REGISTRY = "1";
-    globalThis.fetch = (async () => mockJsonResponse(200, { version: 1, sellers: [] })) as unknown as typeof globalThis.fetch;
-    try {
-      await expect(fetchSellerRegistry(DEFAULT_SELLER_REGISTRY_URL)).resolves.toMatchObject({ version: 1, sellers: [] });
-    } finally {
-      if (previous === undefined) {
-        delete process.env.TB_PROXYD_ALLOW_UNSIGNED_REGISTRY;
-      } else {
-        process.env.TB_PROXYD_ALLOW_UNSIGNED_REGISTRY = previous;
-      }
-    }
-  });
-
-  test("fetchSellerRegistryWithTrust returns hash and unsigned trust metadata for allowed local development", async () => {
-    const previous = process.env.TB_PROXYD_ALLOW_UNSIGNED_REGISTRY;
-    process.env.TB_PROXYD_ALLOW_UNSIGNED_REGISTRY = "1";
-    const body = JSON.stringify({ version: 1, sellers: [] });
-    globalThis.fetch = (async () => new Response(body, {
-      status: 200,
-      headers: { "Content-Type": "application/json" }
-    })) as unknown as typeof globalThis.fetch;
-    try {
-      const result = await fetchSellerRegistryWithTrust(DEFAULT_SELLER_REGISTRY_URL);
-      expect(result.registry).toMatchObject({ version: 1, sellers: [] });
-      expect(result.trust).toMatchObject({
-        registryUrl: DEFAULT_SELLER_REGISTRY_URL,
-        registrySha256: crypto.createHash("sha256").update(body).digest("hex"),
-        verified: false
-      });
-      expect(result.trust.signature).toBeUndefined();
-      expect(result.trust.signingKeyId).toBeUndefined();
-    } finally {
-      if (previous === undefined) {
-        delete process.env.TB_PROXYD_ALLOW_UNSIGNED_REGISTRY;
-      } else {
-        process.env.TB_PROXYD_ALLOW_UNSIGNED_REGISTRY = previous;
-      }
-    }
-  });
-
-  test("RegistryTooLargeError is a stable Error subclass with a useful message", () => {
-    const err = new RegistryTooLargeError({
-      status: 413,
-      sizeBytes: 2_500_000,
-      sellerCount: 1500,
-      maxBytes: 1_000_000
-    });
-    expect(err).toBeInstanceOf(Error);
-    expect(err.name).toBe("RegistryTooLargeError");
-    expect(err.message).toContain("1500 sellers");
-    expect(err.message).toContain("2500000");
-  });
-});

package/tests/seller-catalog-utilities.test.ts

@@ -1,124 +0,0 @@
-import {
-  dedupeCatalogEntries,
-  discoverSellerBackedModels,
-  filterCatalogByProtocol,
-  filterCatalogBySeller,
-  manifestModelIds,
-  type ModelCatalogEntry,
-  type SellerManifest
-} from "../src/seller-catalog.js";
-
-function model(overrides: Partial<ModelCatalogEntry> & { id: string; sellerId: string }): ModelCatalogEntry {
-  return {
-    id: overrides.id,
-    sellerId: overrides.sellerId,
-    sellerUrl: overrides.sellerUrl ?? `https://${overrides.sellerId}.example.com`,
-    supportedProtocols: overrides.supportedProtocols ?? ["chat_completions"],
-    paymentMethods: overrides.paymentMethods ?? ["mock"],
-    sellerName: overrides.sellerName,
-    inputPriceMicrosPer1m: overrides.inputPriceMicrosPer1m,
-    outputPriceMicrosPer1m: overrides.outputPriceMicrosPer1m
-  };
-}
-
-describe("seller catalog utilities", () => {
-  test("filters catalog entries by protocol", () => {
-    const entries = [
-      model({ id: "gpt-5.4", sellerId: "seller-a", supportedProtocols: ["chat_completions"] }),
-      model({ id: "claude", sellerId: "seller-b", supportedProtocols: ["messages"] })
-    ];
-
-    expect(filterCatalogByProtocol([], "chat_completions")).toEqual([]);
-    expect(filterCatalogByProtocol(entries, "chat_completions")).toEqual([entries[0]]);
-    expect(filterCatalogByProtocol(entries, "responses")).toEqual([]);
-  });
-
-  test("filters catalog entries by seller when seller id is provided", () => {
-    const entries = [
-      model({ id: "m1", sellerId: "seller-a" }),
-      model({ id: "m2", sellerId: "seller-b" })
-    ];
-
-    expect(filterCatalogBySeller([], "seller-a")).toEqual([]);
-    expect(filterCatalogBySeller(entries, "seller-a")).toEqual([entries[0]]);
-    expect(filterCatalogBySeller(entries, undefined)).toEqual(entries);
-  });
-
-  test("deduplicates by seller id and model id while preserving order", () => {
-    const first = model({ id: "same", sellerId: "seller-a" });
-    const duplicate = model({ id: "same", sellerId: "seller-a", sellerUrl: "https://duplicate.example.com" });
-    const sameModelDifferentSeller = model({ id: "same", sellerId: "seller-b" });
-    const other = model({ id: "other", sellerId: "seller-a" });
-
-    expect(dedupeCatalogEntries([first, duplicate, sameModelDifferentSeller, other])).toEqual([
-      first,
-      sameModelDifferentSeller,
-      other
-    ]);
-  });
-
-  test("returns trimmed, non-empty manifest model ids only", () => {
-    const manifest = {
-      models: [
-        { id: "  gpt-5.4  " },
-        { id: "" },
-        { id: "claude" }
-      ]
-    } as unknown as SellerManifest;
-
-    expect(manifestModelIds(manifest)).toEqual(["gpt-5.4", "claude"]);
-  });
-
-  test("discovers models from active buyer-visible registry sellers only", async () => {
-    const fetchMock = jest.spyOn(globalThis, "fetch").mockImplementation(async (url) => {
-      const href = String(url);
-      if (href.endsWith("/registry/sellers")) {
-        return jsonResponse({
-          version: 8,
-          sellers: [
-            {
-              id: "active",
-              status: "active",
-              url: "https://active.example.com",
-              supportedProtocols: ["chat_completions"],
-              paymentMethods: ["clawtip"]
-            },
-            {
-              id: "pending",
-              status: "pending",
-              url: "https://pending.example.com",
-              supportedProtocols: ["chat_completions"],
-              paymentMethods: ["clawtip"]
-            }
-          ]
-        });
-      }
-      if (href === "https://active.example.com/manifest") {
-        return jsonResponse({
-          sellerId: "active",
-          supportedProtocols: ["chat_completions"],
-          paymentMethods: ["clawtip"],
-          models: [{ id: "gpt-5.4" }]
-        });
-      }
-      throw new Error(`unexpected fetch ${href}`);
-    });
-
-    try {
-      const catalog = await discoverSellerBackedModels("https://bootstrap.example.com/registry/sellers");
-
-      expect(catalog.sellers.map((seller) => seller.id)).toEqual(["active"]);
-      expect(catalog.models.map((model) => model.sellerId)).toEqual(["active"]);
-      expect(fetchMock).not.toHaveBeenCalledWith("https://pending.example.com/manifest");
-    } finally {
-      fetchMock.mockRestore();
-    }
-  });
-});
-
-function jsonResponse(body: unknown): Response {
-  return new Response(JSON.stringify(body), {
-    status: 200,
-    headers: { "Content-Type": "application/json" }
-  });
-}

package/tests/seller-concurrency-limiter.test.ts

@@ -1,83 +0,0 @@
-import { SellerConcurrencyLimiter } from "../src/seller-concurrency-limiter.js";
-
-describe("SellerConcurrencyLimiter", () => {
-  afterEach(() => {
-    jest.useRealTimers();
-  });
-
-  test("returns disabled no-op leases by default", () => {
-    const limiter = new SellerConcurrencyLimiter();
-    const first = limiter.tryAcquire("seller-a");
-    const second = limiter.tryAcquire("seller-a");
-
-    expect(first).toBeDefined();
-    expect(second).toBeDefined();
-    expect(limiter.snapshot()).toEqual({
-      enabled: false,
-      maxInFlightPerSeller: 2,
-      leaseTtlMs: 185000,
-      active: []
-    });
-  });
-
-  test("rejects sellers at the local in-flight limit and releases idempotently", () => {
-    const limiter = new SellerConcurrencyLimiter({
-      enabled: true,
-      maxInFlightPerSeller: 1,
-      leaseTtlMs: 10000
-    });
-
-    const lease = limiter.tryAcquire("seller-a");
-    expect(lease).toBeDefined();
-    expect(limiter.tryAcquire("seller-a")).toBeUndefined();
-    expect(limiter.tryAcquire("seller-b")).toBeDefined();
-    expect(limiter.snapshot().active).toEqual([
-      { sellerId: "seller-a", activeCount: 1 },
-      { sellerId: "seller-b", activeCount: 1 }
-    ]);
-
-    lease?.release();
-    lease?.release();
-
-    expect(limiter.tryAcquire("seller-a")).toBeDefined();
-  });
-
-  test("expires leaked leases so sellers become selectable again", () => {
-    jest.useFakeTimers();
-    const limiter = new SellerConcurrencyLimiter({
-      enabled: true,
-      maxInFlightPerSeller: 1,
-      leaseTtlMs: 1000
-    });
-
-    expect(limiter.tryAcquire("seller-a")).toBeDefined();
-    expect(limiter.tryAcquire("seller-a")).toBeUndefined();
-
-    jest.advanceTimersByTime(1000);
-
-    expect(limiter.snapshot().active).toEqual([]);
-    expect(limiter.tryAcquire("seller-a")).toBeDefined();
-  });
-
-  test("refresh extends an active lease watchdog", () => {
-    jest.useFakeTimers();
-    const limiter = new SellerConcurrencyLimiter({
-      enabled: true,
-      maxInFlightPerSeller: 1,
-      leaseTtlMs: 1000
-    });
-
-    const lease = limiter.tryAcquire("seller-a");
-    expect(lease).toBeDefined();
-
-    jest.advanceTimersByTime(900);
-    lease?.refresh();
-    jest.advanceTimersByTime(900);
-
-    expect(limiter.snapshot().active).toEqual([{ sellerId: "seller-a", activeCount: 1 }]);
-
-    jest.advanceTimersByTime(100);
-
-    expect(limiter.snapshot().active).toEqual([]);
-  });
-});

package/tests/seller-metadata-cache.test.ts

@@ -1,89 +0,0 @@
-import * as http from "http";
-import { SellerMetadataCache } from "../src/seller-metadata-cache.js";
-import type { RegistrySeller } from "../src/seller-catalog.js";
-
-function seller(id: string, url: string): RegistrySeller {
-  return {
-    id,
-    url,
-    supportedProtocols: ["chat_completions"],
-    paymentMethods: ["clawtip"],
-    models: ["gpt-5.4"]
-  };
-}
-
-function startManifestServer(handler: (req: http.IncomingMessage, res: http.ServerResponse) => void): Promise<{
-  url: string;
-  close: () => Promise<void>;
-}> {
-  const server = http.createServer(handler);
-  return new Promise((resolve) => {
-    server.listen(0, "127.0.0.1", () => {
-      const address = server.address();
-      if (!address || typeof address === "string") {
-        throw new Error("server did not bind to a TCP port");
-      }
-      resolve({
-        url: `http://127.0.0.1:${address.port}`,
-        close: () => new Promise<void>((done) => server.close(() => done()))
-      });
-    });
-  });
-}
-
-describe("seller metadata cache", () => {
-  test("reads discount ratio and manifest version from seller manifest selection", async () => {
-    let requestCount = 0;
-    const server = await startManifestServer((req, res) => {
-      requestCount += 1;
-      expect(req.url).toBe("/manifest");
-      res.setHeader("Content-Type", "application/json");
-      res.end(JSON.stringify({
-        manifestVersion: "manifest.test",
-        selection: {
-          discountRatio: 0.42
-        }
-      }));
-    });
-
-    try {
-      const cache = new SellerMetadataCache({ ttlMs: 60_000, now: () => 1000 });
-      await cache.refreshIfStale([seller("s1", server.url)]);
-      await cache.refreshIfStale([seller("s1", server.url)]);
-
-      expect(requestCount).toBe(1);
-      expect(cache.snapshot()).toEqual([
-        {
-          sellerId: "s1",
-          discountRatio: 0.42,
-          manifestVersion: "manifest.test",
-          lastRefreshAt: 1000,
-          source: "manifest_selection"
-        }
-      ]);
-    } finally {
-      await server.close();
-    }
-  });
-
-  test("stores manifest fetch failures without throwing", async () => {
-    const server = await startManifestServer((req, res) => {
-      res.statusCode = 500;
-      res.end("nope");
-    });
-
-    try {
-      const cache = new SellerMetadataCache({ ttlMs: 60_000, now: () => 2000 });
-      await expect(cache.refreshIfStale([seller("s1", server.url)])).resolves.toBeUndefined();
-
-      expect(cache.snapshot()[0]).toMatchObject({
-        sellerId: "s1",
-        lastRefreshAt: 2000,
-        source: "manifest_selection",
-        errorMessage: "manifest returned 500"
-      });
-    } finally {
-      await server.close();
-    }
-  });
-});