@convex-dev/ai-budget 0.0.2-alpha.16 → 0.0.2-alpha.18

package/src/client/index.ts

@@ -172,8 +172,21 @@ function extractUsage(usage: any): {
   cachedTokens: number;
 } {
   return {
-    promptTokens: toTokenCount(usage?.inputTokens ?? usage?.promptTokens),
-    completionTokens: toTokenCount(usage?.outputTokens ?? usage?.completionTokens),
+    // Cover AI SDK camelCase (v5/v7), raw OpenAI-compatible snake_case, AND raw
+    // Anthropic (`input_tokens`/`output_tokens`), so a `meter` caller passing any
+    // provider's raw `usage` object still gets counts.
+    promptTokens: toTokenCount(
+      usage?.inputTokens ??
+        usage?.promptTokens ??
+        usage?.prompt_tokens ??
+        usage?.input_tokens
+    ),
+    completionTokens: toTokenCount(
+      usage?.outputTokens ??
+        usage?.completionTokens ??
+        usage?.completion_tokens ??
+        usage?.output_tokens
+    ),
     // cached prompt tokens. The Convex gateway reports these at
     // `usage.inputTokenDetails.cacheReadTokens`; the other paths cover AI SDK v5
     // (`cachedInputTokens`) and raw OpenAI-compatible shapes.
@@ -182,7 +195,8 @@ function extractUsage(usage: any): {
         usage?.cachedInputTokens ??
         usage?.promptTokensDetails?.cachedTokens ??
         usage?.prompt_tokens_details?.cached_tokens ??
-        usage?.cached_tokens
+        usage?.cached_tokens ??
+        usage?.cache_read_input_tokens
     ),
   };
 }
@@ -208,6 +222,12 @@ function extractGatewayCostNanos(result: any): number | undefined {
 
 const NANOS_PER_DOLLAR = 1e9;
 
+// Cap stored prompt/response content so one row can't approach Convex's 1 MiB
+// document limit (which would fail the call) or bloat the reconciler's scans.
+const MAX_STORED_CONTENT = 32 * 1024;
+const capContent = (s: string) =>
+  s.length > MAX_STORED_CONTENT ? s.slice(0, MAX_STORED_CONTENT) + "…[truncated]" : s;
+
 // Flatten an AI SDK prompt (roles + content parts) into simple storable messages.
 function simplifyPrompt(prompt: any): Message[] {
   if (!Array.isArray(prompt)) return [];
@@ -217,14 +237,20 @@ function simplifyPrompt(prompt: any): Message[] {
       content = m.content;
     } else if (Array.isArray(m.content)) {
       content = m.content
-        .map((part: any) =>
-          part?.type === "text" ? part.text : JSON.stringify(part)
-        )
+        .map((part: any) => {
+          if (part?.type === "text") return part.text ?? "";
+          // NEVER inline a base64 image/file part — a data URL or Uint8Array here
+          // becomes megabytes, pushing the stored row past the 1 MiB doc limit
+          // (failing the call) and turning a 200 KB image into a ~50k-token
+          // estimate. Store a compact placeholder.
+          const bytes = part?.data?.length ?? part?.image?.length ?? part?.data?.byteLength;
+          return `[${part?.type ?? "part"}${typeof bytes === "number" ? ` ${bytes}b` : ""}]`;
+        })
         .join("");
     } else {
       content = JSON.stringify(m.content);
     }
-    return { role: String(m.role), content };
+    return { role: String(m.role), content: capContent(content) };
   });
 }
 
@@ -463,35 +489,42 @@ export class AIBudget {
     }
     const { requestId, warnings, notices } = started;
     const start = Date.now();
+    // Run the provider call. ONLY a failure of the call itself settles as an
+    // error (no charge expected).
+    let out: Awaited<ReturnType<typeof run>>;
     try {
-      const out = await run();
-      const { costNanos } = await this.settle(ctx, {
-        requestId,
-        responseText: out.text,
-        usage: out.usage,
-        promptTokens: out.promptTokens,
-        completionTokens: out.completionTokens,
-        cachedTokens: out.cachedTokens,
-        serverToolUses: out.serverToolUses,
-        costNanos: out.costNanos,
-        latencyMs: Date.now() - start,
-      });
-      // Re-derive the recorded usage for the return value.
-      const usage =
-        out.promptTokens !== undefined ||
-        out.completionTokens !== undefined ||
-        out.cachedTokens !== undefined
-          ? {
-              promptTokens: out.promptTokens ?? 0,
-              completionTokens: out.completionTokens ?? 0,
-              cachedTokens: out.cachedTokens ?? 0,
-            }
-          : extractUsage(out.usage);
-      return { text: out.text ?? "", requestId, costNanos, warnings, notices, ...usage };
+      out = await run();
     } catch (e) {
       await this.settle(ctx, { requestId, error: String(e), latencyMs: Date.now() - start });
       throw e;
     }
+    // The call SUCCEEDED (the provider may have charged). Settle the real usage.
+    // If settlement itself fails here, do NOT fall into an error-settle that
+    // records zero — that would erase a real charge. Rethrow and leave the
+    // reservation for the reconciler; billing stays "unknown", never a false zero.
+    const { costNanos } = await this.settle(ctx, {
+      requestId,
+      responseText: out.text,
+      usage: out.usage,
+      promptTokens: out.promptTokens,
+      completionTokens: out.completionTokens,
+      cachedTokens: out.cachedTokens,
+      serverToolUses: out.serverToolUses,
+      costNanos: out.costNanos,
+      latencyMs: Date.now() - start,
+    });
+    // Re-derive the recorded usage for the return value.
+    const usage =
+      out.promptTokens !== undefined ||
+      out.completionTokens !== undefined ||
+      out.cachedTokens !== undefined
+        ? {
+            promptTokens: out.promptTokens ?? 0,
+            completionTokens: out.completionTokens ?? 0,
+            cachedTokens: out.cachedTokens ?? 0,
+          }
+        : extractUsage(out.usage);
+    return { text: out.text ?? "", requestId, costNanos, warnings, notices, ...usage };
   }
 
   /**
@@ -717,15 +750,10 @@ export class AIBudget {
         wrapGenerate: async ({ doGenerate, params }: any) => {
           const requestId = await begin(params);
           const start = Date.now();
+          // Only a failure of the generation itself settles as an error.
+          let result: any;
           try {
-            const result = await doGenerate();
-            await finish(requestId, {
-              responseText: extractText(result),
-              ...extractUsage(result.usage),
-              costNanos: extractGatewayCostNanos(result),
-              latencyMs: Date.now() - start,
-            });
-            return result;
+            result = await doGenerate();
           } catch (e) {
             await finish(requestId, {
               error: String(e),
@@ -733,6 +761,15 @@ export class AIBudget {
             });
             throw e;
           }
+          // Generation succeeded (provider may have charged). Settle the real
+          // usage; a failure here rethrows rather than recording a false zero.
+          await finish(requestId, {
+            responseText: extractText(result),
+            ...extractUsage(result.usage),
+            costNanos: extractGatewayCostNanos(result),
+            latencyMs: Date.now() - start,
+          });
+          return result;
         },
         wrapStream: async ({ doStream, params }: any) => {
           const requestId = await begin(params);
@@ -747,21 +784,24 @@ export class AIBudget {
             // chunk, or a cancel — is safe: the first wins, the rest no-op.
             // Without this an errored or abandoned stream would never settle and
             // its real usage would be lost (recorded as free by the reconciler).
-            let settled = false;
-            const settle = (error?: string) => {
-              if (settled) return;
-              settled = true;
-              return finish(requestId, {
+            // Settle at most once, memoizing the PROMISE so the finish chunk, an
+            // error chunk, and flush all await the same settlement instead of
+            // racing, dropping it (the old `void settle()`), or flipping a
+            // "settled" flag before the mutation actually committed. A stream
+            // that is cancelled/never fully consumed won't deliver finish or
+            // flush; the reconciler's reservation expiry is the backstop there.
+            let settlement: Promise<{ costNanos: number }> | undefined;
+            const settle = (error?: string) =>
+              (settlement ??= finish(requestId, {
                 responseText: text,
                 error,
                 ...extractUsage(usage),
                 costNanos: extractGatewayCostNanos({ providerMetadata }),
                 latencyMs: Date.now() - start,
-              });
-            };
+              }));
             const tapped = result.stream.pipeThrough(
               new TransformStream({
-                transform(chunk: any, controller) {
+                async transform(chunk: any, controller: any) {
                   if (chunk?.type === "text-delta") {
                     text += chunk.delta ?? chunk.textDelta ?? "";
                   }
@@ -769,13 +809,30 @@ export class AIBudget {
                     usage = chunk.usage;
                     providerMetadata = chunk.providerMetadata ?? providerMetadata;
                   }
-                  if (chunk?.type === "error") void settle(String(chunk.error));
                   controller.enqueue(chunk);
+                  // Settle after forwarding the terminal error chunk, and AWAIT
+                  // it so a failed settle surfaces instead of being dropped.
+                  if (chunk?.type === "error") await settle(String(chunk.error));
                 },
                 async flush() {
                   await settle();
                 },
-              })
+                // A cancelled/aborted stream (client disconnect, AbortSignal, or
+                // breaking out of `for await`) does NOT run `flush`. Without this
+                // the request would sit pending until the 30-min reservation
+                // expiry and be recorded as $0 though the provider charged for
+                // what streamed. Settle here with the text so far, estimating the
+                // completion tokens when the provider gave no usage.
+                // `cancel` is a newer Streams-spec transformer hook not yet in
+                // the TS DOM lib types; cast the literal so it compiles (runtimes
+                // without it simply won't call it, and the reconciler backstops).
+                async cancel(reason: any) {
+                  if (usage === undefined && text) {
+                    usage = { outputTokens: Math.ceil(text.length / 4) };
+                  }
+                  await settle(`cancelled: ${String(reason)}`);
+                },
+              } as any)
             );
             return { ...result, stream: tapped };
           } catch (e) {
@@ -1037,17 +1094,29 @@ export class AIBudget {
       if (!token) return { ok: false, token: "" };
       const url = new URL(request.url);
       const bearer = (request.headers.get("authorization") ?? "").replace(/^Bearer\s+/i, "");
-      // `?token=` is accepted only for the initial page navigation (a browser
-      // GET can't set headers); the page strips it from the URL on load and the
-      // JSON API is called with the bearer header. Compared in constant time.
-      const provided = bearer || url.searchParams.get("token") || "";
+      // `?token=` is accepted ONLY for the initial page navigation (a browser GET
+      // can't set headers); the page strips it from the URL on load and calls the
+      // JSON API with the bearer header. Restrict it to that GET page route so a
+      // token can't be smuggled in a query string on API/mutation calls (where it
+      // would also land in access logs). Compared in constant time.
+      const sub = url.pathname.slice(prefix.length) || "/";
+      const isPageNav = request.method === "GET" && !sub.startsWith("/api");
+      const provided = bearer || (isPageNav ? url.searchParams.get("token") ?? "" : "");
       return { ok: timingSafeEqual(provided, token), token };
     };
     const json = (data: unknown, status = 200) =>
       new Response(JSON.stringify(data ?? null), {
         status,
-        headers: { "content-type": "application/json" },
+        // Never let a shared cache/proxy retain budget data or the token-bearing
+        // page — these responses are per-viewer and sensitive.
+        headers: { "content-type": "application/json", "cache-control": "no-store" },
       });
+    // JSON.stringify does NOT escape `<`, so a value containing `</script>`
+    // would close the inline <script> and break out. Escape `<` (and the JS line
+    // separators) before embedding in HTML.
+    const jsonForScript = (x: unknown) =>
+      JSON.stringify(x).replace(/[<\u2028\u2029]/g, (ch) =>
+        "\\u" + ch.charCodeAt(0).toString(16).padStart(4, "0"));
 
     const handle = async (ctx: any, request: Request): Promise<Response> => {
       const url = new URL(request.url);
@@ -1111,15 +1180,19 @@ export class AIBudget {
         }
       }
 
-      // Inject as JSON literals (function replacers so `$` in the value isn't
-      // treated as a replacement pattern). This keeps a token/prefix containing
-      // quotes, backslashes, or `</script>` from breaking out of the JS string.
+      // Inject as script-safe JSON literals (function replacers so `$` in the
+      // value isn't treated as a replacement pattern; `jsonForScript` escapes
+      // `<` so a token containing `</script>` can't break out of the inline JS).
       const html = DASHBOARD_HTML.replace(
         /__API_BASE__/g,
-        () => JSON.stringify(`${prefix}/api`)
-      ).replace(/__TOKEN__/g, () => JSON.stringify(token));
+        () => jsonForScript(`${prefix}/api`)
+      ).replace(/__TOKEN__/g, () => jsonForScript(token));
+      // The page embeds the bearer token — never let a shared cache retain it.
       return new Response(html, {
-        headers: { "content-type": "text/html; charset=utf-8" },
+        headers: {
+          "content-type": "text/html; charset=utf-8",
+          "cache-control": "no-store",
+        },
       });
     };
 

package/src/component/_generated/component.ts

@@ -185,9 +185,9 @@ export type ComponentApi<Name extends string | undefined = string | undefined> =
         "mutation",
         "internal",
         {
-          dailySpendLimitNanos?: number;
-          enforcement?: "hard" | "soft";
-          lifetimeSpendLimitNanos?: number;
+          dailySpendLimitNanos?: number | null;
+          enforcement?: "hard" | "soft" | null;
+          lifetimeSpendLimitNanos?: number | null;
         },
         null,
         Name

package/src/component/lib.test.ts

@@ -332,8 +332,8 @@ describe("per-bucket rate limits", () => {
     const t = initTest();
     await setUserLimits(t, "u", { requestsPerMinute: 0 });
     expect((await start(t, { userId: "u" })).code).toBe("rate_limit");
-    for (const requestsPerMinute of [-1, 0.5, Number.MAX_SAFE_INTEGER + 1]) {
-      await expect(setUserLimits(t, "u", { requestsPerMinute })).rejects.toThrow("nonnegative safe integer");
+    for (const requestsPerMinute of [-1, 0.5, Number.MAX_SAFE_INTEGER + 1, NaN, Infinity]) {
+      await expect(setUserLimits(t, "u", { requestsPerMinute })).rejects.toThrow(/requestsPerMinute/);
     }
   });
 
@@ -533,15 +533,17 @@ describe("model policy", () => {
 });
 
 describe("D-02 pricing validation", () => {
-  test("setPrice rejects negative rates", async () => {
-    const t = initTest();
-    await expect(
-      t.mutation(api.lib.setPrice, {
-        model: "x/y",
-        inputNanosPerMTok: -1,
-        outputNanosPerMTok: 5,
-      })
-    ).rejects.toThrow(/non-negative/);
+  test("setPrice rejects negative and non-finite rates", async () => {
+    const t = initTest();
+    for (const inputNanosPerMTok of [-1, NaN, Infinity, 0.5]) {
+      await expect(
+        t.mutation(api.lib.setPrice, {
+          model: "x/y",
+          inputNanosPerMTok,
+          outputNanosPerMTok: 5,
+        })
+      ).rejects.toThrow(/inputNanosPerMTok/);
+    }
   });
 });
 
@@ -552,8 +554,9 @@ describe("F-04 fail-closed pricing", () => {
     expect(r.allowed).toBe(true);
     await settle(t, r.requestId, 1_000_000, 1_000_000);
     const u = await userOf(t, "u");
-    // conservative = max over table = {$3 in, $15 out}/Mtok => $18 = 18e9 nano.
-    expect(u.totalSpendNanos).toBe(18_000_000_000);
+    // Conservative fallback is a frontier ceiling of {$20 in, $100 out}/Mtok, so
+    // 1M in + 1M out => $120 = 120e9 nano (over-count is the safe direction).
+    expect(u.totalSpendNanos).toBe(120_000_000_000);
     const req = (await t.query(api.lib.getRequest, { requestId: r.requestId }))!;
     expect(req.unpricedModel).toBe(true);
   });
@@ -596,7 +599,7 @@ describe("accounting lifecycle regressions", () => {
       await setUserLimits(t, "u", { dailySpendLimitNanos: 1000 });
       const job = await start(t, { userId: "u", estimatedCostNanos: 100 });
       vi.advanceTimersByTime(2 * 60 * 60_000);
-      await t.mutation(internal.lib.reconcile, {});
+      await t.mutation(internal.lib.expirePhase, {});
       expect((await userOf(t, "u")).reservedTotalNanos).toBe(0);
       await start(t, { userId: "u", estimatedCostNanos: 100 });
       await t.mutation(api.lib.finishRequest, { requestId: job.requestId, costNanos: 75 });
@@ -623,7 +626,7 @@ describe("accounting lifecycle regressions", () => {
       });
       const short = await start(t, { userId: "short" });
       vi.advanceTimersByTime(31 * 60_000);
-      const result = await t.mutation(internal.lib.reconcile, {});
+      const result = await t.mutation(internal.lib.expirePhase, {});
       expect(result.expired).toBe(1);
       expect((await t.run(ctx => ctx.db.get(short.requestId))).reservationExpired).toBe(true);
     } finally { vi.useRealTimers(); }
@@ -662,9 +665,11 @@ test("legacy pending rows acquire deadlines without starving newer expired work"
     });
     const job = await start(t, { userId: "new" });
     vi.advanceTimersByTime(31 * 60_000);
-    expect((await t.mutation(internal.lib.reconcile, {})).expired).toBe(1);
+    expect((await t.mutation(internal.lib.expirePhase, {})).expired).toBe(1);
     expect((await t.run(ctx => ctx.db.get(job.requestId))).reservationExpired).toBe(true);
-    await t.mutation(internal.lib.reconcile, {});
+    // The phase self-reschedules to backfill the remaining legacy rows in
+    // batches; drain those scheduled continuations.
+    await t.finishAllScheduledFunctions(vi.runAllTimers);
     expect(await t.run(ctx => ctx.db.query("requests").withIndex("status_expires", q =>
       q.eq("status", "pending").eq("expiresAt", undefined)).take(1))).toHaveLength(0);
   } finally { vi.useRealTimers(); }
@@ -683,7 +688,7 @@ test("retention progresses past unresolved jobs", async () => {
     await t.mutation(api.lib.finishRequest, { requestId: job.requestId, costNanos: 0 });
     await t.mutation(internal.lib.foldTotals, { requestId: job.requestId });
     vi.advanceTimersByTime(2 * 60 * 60_000);
-    expect((await t.mutation(internal.lib.reconcile, {})).purged).toBe(1);
+    expect((await t.mutation(internal.lib.retentionPhase, {})).purged).toBe(1);
     expect(await t.run(ctx => ctx.db.get(job.requestId))).toBeNull();
   } finally { vi.useRealTimers(); }
 });
@@ -707,3 +712,135 @@ test("delayed folding attributes spend to completion day and leaves newer holds
     expect(history[0].spendNanos).toBe(50);
   } finally { vi.useRealTimers(); }
 });
+
+describe("v1 hardening", () => {
+  test("setGlobalLimits: a one-field update preserves the other global limits", async () => {
+    const t = initTest();
+    await t.mutation(api.lib.setGlobalLimits, {
+      dailySpendLimitNanos: 100,
+      lifetimeSpendLimitNanos: 500,
+      enforcement: "soft",
+    });
+    // Update ONLY the daily cap — must not wipe lifetime/enforcement.
+    await t.mutation(api.lib.setGlobalLimits, { dailySpendLimitNanos: 200 });
+    const g = await t.query(api.lib.getGlobalStatus, {});
+    expect(g.dailySpendLimitNanos).toBe(200);
+    expect(g.lifetimeSpendLimitNanos).toBe(500);
+    expect(g.enforcement).toBe("soft");
+    // Explicit null clears just that field.
+    await t.mutation(api.lib.setGlobalLimits, { lifetimeSpendLimitNanos: null });
+    const after = await t.query(api.lib.getGlobalStatus, {});
+    expect(after.lifetimeSpendLimitNanos).toBe(null);
+    expect(after.dailySpendLimitNanos).toBe(200);
+  });
+
+  test("finishRequest on a missing/deleted request is a graceful no-op", async () => {
+    const t = initTest();
+    const r = await start(t, { userId: "u" });
+    await t.mutation(api.lib.deleteBucket, { dimension: "user", value: "u" });
+    // The request row is gone; a late/duplicate webhook must not throw.
+    const out = await t.mutation(api.lib.finishRequest, {
+      requestId: r.requestId,
+      costNanos: 1_000_000,
+    });
+    expect(out.costNanos).toBe(0);
+  });
+
+  test("deleting a user releases holds it placed on a shared bucket", async () => {
+    const t = initTest();
+    // A shared action bucket with a cap, so requests reserve against it.
+    await t.mutation(api.lib.setBucketLimits, {
+      dimension: "action",
+      value: "shared",
+      lifetimeSpendLimitNanos: 1_000_000_000,
+    });
+    // A pending (unsettled) request from user "u" attributed to that action.
+    await start(t, { userId: "u", actionName: "shared" });
+    let action = await bucketOf(t, "action", "shared");
+    expect(action.reservedTotalNanos).toBeGreaterThan(0);
+    expect(action.pendingCount).toBe(1);
+    // Deleting the user must free the shared bucket's hold, not strand it.
+    await t.mutation(api.lib.deleteBucket, { dimension: "user", value: "u" });
+    action = await bucketOf(t, "action", "shared");
+    expect(action.reservedTotalNanos ?? 0).toBe(0);
+    expect(action.pendingCount ?? 0).toBe(0);
+  });
+
+  test("a NaN/Infinity cost or token count cannot poison bucket totals", async () => {
+    const t = initTest();
+    const r = await start(t, { userId: "u" });
+    await t.mutation(api.lib.finishRequest, {
+      requestId: r.requestId,
+      costNanos: NaN,          // ignored (not finite) -> token pricing
+      promptTokens: NaN,       // coerced to 0
+      completionTokens: 5,
+    });
+    vi.useFakeTimers();
+    await t.finishAllScheduledFunctions(vi.runAllTimers);
+    vi.useRealTimers();
+    const u = await userOf(t, "u");
+    expect(Number.isFinite(u.totalSpendNanos)).toBe(true);
+    expect(Number.isFinite(u.spendTodayNanos)).toBe(true);
+    expect(u.totalSpendNanos).toBeGreaterThanOrEqual(0);
+  });
+
+  test("a NaN limit is rejected rather than admitting unlimited spend", async () => {
+    const t = initTest();
+    await expect(
+      setUserLimits(t, "u", { dailySpendLimitNanos: NaN })
+    ).rejects.toThrow(/dailySpendLimitNanos/);
+    await expect(
+      setUserLimits(t, "u", { dailySpendLimitNanos: Infinity })
+    ).rejects.toThrow(/dailySpendLimitNanos/);
+  });
+});
+
+describe("v1 hardening (round 2)", () => {
+  test("a non-finite estimatedCostNanos is rejected before it can poison a bucket", async () => {
+    const t = initTest();
+    for (const estimatedCostNanos of [Infinity, NaN, -1]) {
+      await expect(
+        start(t, { userId: "u", estimatedCostNanos })
+      ).rejects.toThrow(/estimatedCostNanos/);
+    }
+  });
+
+  test("a settle with no cost signal falls back to the reserved estimate, not $0", async () => {
+    const t = initTest();
+    // $2 reserved up front (e.g. a video job).
+    const r = await start(t, { userId: "u", estimatedCostNanos: 2_000_000_000 });
+    // Settle with an unpriced server tool and no tokens/authoritative cost.
+    const out = await t.mutation(api.lib.finishRequest, {
+      requestId: r.requestId,
+      serverToolUses: { video_seconds: 8 }, // no configured price
+    });
+    expect(out.costNanos).toBe(2_000_000_000); // NOT 0
+    vi.useFakeTimers();
+    await t.finishAllScheduledFunctions(vi.runAllTimers);
+    vi.useRealTimers();
+    const u = await userOf(t, "u");
+    expect(u.totalSpendNanos).toBe(2_000_000_000);
+  });
+});
+
+describe("v1 hardening (round 3): reconcile phases", () => {
+  test("expired tombstones are deleted after the late-settle horizon", async () => {
+    vi.useFakeTimers();
+    try {
+      const t = initTest();
+      const job = await start(t, { userId: "u", estimatedCostNanos: 100 });
+      vi.advanceTimersByTime(31 * 60_000);
+      // Expire it into a billing tombstone (reservationExpired + settled).
+      await t.mutation(internal.lib.expirePhase, {});
+      // Within the 7-day late-settle horizon: retention keeps the tombstone.
+      await t.mutation(internal.lib.retentionPhase, {});
+      expect(await t.run((ctx) => ctx.db.get(job.requestId))).not.toBeNull();
+      // Past the horizon: the tombstone is deleted so they can't accumulate.
+      vi.advanceTimersByTime(8 * 24 * 60 * 60_000);
+      await t.mutation(internal.lib.retentionPhase, {});
+      expect(await t.run((ctx) => ctx.db.get(job.requestId))).toBeNull();
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+});