fix(node): a test about arithmetic was failing on a timeout

"never exceeds the configured ceiling" made 400 sequential Durable Object
round-trips to drive proof-of-work difficulty past its cap. Reaching the cap
takes 24 — one bit per CREATES_PER_EXTRA_BIT creates, over six bits of headroom
— so the loop was sixteen times longer than the property needed, and slow
enough that a loaded runner blew vitest's 5s default.

Same signature as defect 45: green on CI, red on Deploy staging, same commit.
Two workflows running one suite on differently-loaded runners is the only thing
that separates a test whose runtime decides the result from one whose logic
does.

The number was 400 because CREATES_PER_EXTRA_BIT was module-private, so the
test could not compute the real bound and reached for one comfortably past it.
Exporting it makes the loop derived: (ceiling - floor) * perBit * 2. That is 48
hops instead of 400, 375ms instead of a timeout, and it stays correct if either
bit setting changes — which the magic number did not.

Raising the timeout would have been the wrong fix: it keeps a test that takes
seconds to assert min(a, b), and moves the threshold rather than the cause.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017ND8DWQLFchUayY5xeP6vb

Author: tuanngocptn

apps/node/src/do/source-quota.ts

@@ -48,7 +48,14 @@ const CREATE_WINDOW_MS = 3_600_000
  * in mind — the escalation should still be climbing when the hard cap arrives, or it would be
  * decoration.
  */
-const CREATES_PER_EXTRA_BIT = 4
+/**
+ * Creates per extra bit of difficulty.
+ *
+ * Exported so `test/abuse-controls.test.ts` can work out how many reservations reach the ceiling
+ * instead of guessing a number far past it — the guess was 400 where 24 suffice, and 400 sequential
+ * Durable Object hops is slow enough that the test timed out on a loaded runner (defect 55).
+ */
+export const CREATES_PER_EXTRA_BIT = 4
 
 export interface QuotaLimits {
   readonly maxConcurrent: number

apps/node/test/abuse-controls.test.ts

@@ -11,6 +11,7 @@
 import { reset, SELF, env as testEnv } from "cloudflare:test"
 import { solveChallenge } from "@nport/worker-kit"
 import { afterEach, beforeEach, describe, expect, it } from "vitest"
+import { CREATES_PER_EXTRA_BIT } from "../src/do/source-quota"
 import type { Env } from "../src/types"
 import { FakeCloudflare } from "./fake-cloudflare"
 
@@ -250,11 +251,18 @@ describe("proof-of-work difficulty rises per source", () => {
     // Unbounded escalation would eventually price out a legitimate heavy user permanently, and there
     // is no way for them to appeal to anyone — there are no accounts.
     const quota = env.SOURCE_QUOTA.get(env.SOURCE_QUOTA.idFromName("synthetic"))
+    const floor = Number(env.POW_DIFFICULTY_BITS)
     const ceiling = Number(env.POW_MAX_DIFFICULTY_BITS)
-    for (let index = 0; index < 400; index += 1) {
+
+    // **Derived, not guessed.** Reaching the ceiling takes one bit per `CREATES_PER_EXTRA_BIT`
+    // creates; twice that is comfortably past it, which is the property under test. The previous
+    // 400 was sixteen times more than needed, and 400 sequential Durable Object hops took long
+    // enough that a loaded runner blew the 5 s default and failed a test about *arithmetic*.
+    const pastTheCeiling = (ceiling - floor) * CREATES_PER_EXTRA_BIT * 2
+    for (let index = 0; index < pastTheCeiling; index += 1) {
       await quota.reserve(`bulk${index}`, { maxConcurrent: 10_000, maxPerHour: 10_000 })
     }
-    expect(await quota.difficulty(Number(env.POW_DIFFICULTY_BITS), ceiling)).toBe(ceiling)
+    expect(await quota.difficulty(floor, ceiling)).toBe(ceiling)
   })
 })
 

docs/ROADMAP.md

@@ -925,6 +925,25 @@ into nothing, and swallowed the failure — by design, silently. That was the ga
       a listed-then-idle node slipping out of a directory nobody is reading harms nobody. What it
       blocks is trusting `/v1/nodes` as a health display for a quiet node
 
+**55. A test about arithmetic failed on a timeout.** `abuse-controls.test.ts`'s "never exceeds the
+configured ceiling" made **400 sequential Durable Object round-trips** to drive the proof-of-work
+difficulty past its cap. Reaching the cap takes 24 — one bit per `CREATES_PER_EXTRA_BIT` creates,
+across six bits of headroom — so the loop was sixteen times longer than the property needed, and slow
+enough that a loaded runner blew vitest's 5 s default.
+
+Same signature as defect 45: **green on `CI`, red on `Deploy staging`, same commit.** Two workflows
+running the same suite on differently-loaded runners is the only thing that distinguishes a test
+whose *runtime* decides the result from one whose logic does.
+
+The number was 400 because `CREATES_PER_EXTRA_BIT` was module-private, so the test could not compute
+the real bound and reached for one comfortably past it. Exporting the constant makes the loop
+derived: `(ceiling - floor) * CREATES_PER_EXTRA_BIT * 2`. That is 48 hops rather than 400, the test
+runs in 375 ms rather than timing out, **and it stays correct if either bit setting changes** — which
+the magic number did not.
+
+**Raising the timeout would have been the wrong fix.** It would have kept a test that takes seconds
+to assert `min(a, b)`, and moved the threshold rather than the cause. The guess was the defect.
+
 **54. Four screens had been built without anyone looking at them, and four of them were wrong.**
 `tauri dev` does launch on this machine — the process runs — but the window cannot be captured
 without screen-recording permission, which is why "no browser tier" had been treated as "no way to