cursedbelt-server 4.46.0 → 4.46.1

package/dist/server/storage/binaryStore.js

@@ -417,13 +417,16 @@ export function createBinaryStore(cfg) {
      * caller asked for `paced` and the budget allows, otherwise thrown as a typed error that
      * keeps the `[binary-store] <op> <key>: 429` message batch callers already match.
      */
-    const sendRead = async (op, key, url, init, opts) => {
+    const sendRead = async (op, key, 
+    /** Signs the URL. Called for EVERY attempt: a read token lives 60 s and a paced read may wait
+     *  120 s, so a URL signed once went out dead after the first long retry-after (forge task 3302). */
+    mint, init, opts) => {
         const budget = opts?.paced
             ? (typeof opts.paced === 'object' ? opts.paced.maxWaitMs : undefined) ?? BINARY_PACED_MAX_WAIT_MS
             : 0;
         let waited = 0;
         for (let attempt = 0;; attempt++) {
-            const res = await send(url, init);
+            const res = await send(await mint(), init);
             if (res.status !== 429)
                 return res;
             const retryAfterSec = retryAfterSeconds(res.headers.get('retry-after'), attempt);
@@ -548,7 +551,7 @@ export function createBinaryStore(cfg) {
             if (!opts?.fresh && knownAbsent(key))
                 return null;
             countWireRead(key);
-            const res = await sendRead('get', key, await internalMediaUrl(key), undefined, opts);
+            const res = await sendRead('get', key, () => internalMediaUrl(key), undefined, opts);
             if (res.status === 404) {
                 rememberAbsent(key);
                 return null;
@@ -624,7 +627,7 @@ export function createBinaryStore(cfg) {
                     return null;
             }
             countWireRead(key);
-            const res = await sendRead('meta', key, await metaUrl(key), undefined, opts);
+            const res = await sendRead('meta', key, () => metaUrl(key), undefined, opts);
             if (res.status === 404) {
                 rememberAbsent(key);
                 return null;
@@ -671,7 +674,7 @@ export function createBinaryStore(cfg) {
                     throw why;
             }
             countWireRead(key);
-            const res = await sendRead('stat', key, await internalMediaUrl(key), { headers: { Range: 'bytes=0-0' } }, opts);
+            const res = await sendRead('stat', key, () => internalMediaUrl(key), { headers: { Range: 'bytes=0-0' } }, opts);
             if (res.status === 404) {
                 rememberAbsent(key);
                 return null;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "cursedbelt-server",
-	"version": "4.46.0",
+	"version": "4.46.1",
 	"license": "ISC",
 	"type": "module",
 	"description": "The app-facing Bun/Hono server tier of the cursedbelt split — storage, sharing, activity, guard, sync. React-free; cursedbelt-core below it.",

package/src/server/storage/binaryStore.spec.ts

@@ -26,7 +26,7 @@
  * server; the RSA keypair is generated in-process and the signature is verified with
  * `node:crypto`, which is what makes the token assertions real rather than shape-deep.
  */
-import { afterAll, afterEach, beforeEach, describe, expect, it } from 'bun:test';
+import { afterAll, afterEach, beforeEach, describe, expect, it, setSystemTime } from 'bun:test';
 import { generateKeyPairSync, verify as cryptoVerify } from 'node:crypto';
 import {
   AUTO_CHUNK_THRESHOLD_BYTES,
@@ -1056,6 +1056,29 @@ describe('🔴 a read the store PACES is waited out when asked, typed when not (
     expect(calls).toHaveLength(4);
   });
 
+  it('🔴 every attempt goes with a token signed for IT — a 60 s token outlives no 120 s wait (forge task 3302)', async () => {
+    // The URL was signed once, before the first attempt, so a paced read that waited out 30 s
+    // refusals sent a dead token on its third try, and binary-server answered 403 — not 429.
+    try {
+      let n = 0;
+      reply = () => (n++ < 3 ? limited('30') : ok(new Uint8Array([7, 8])));
+      const store = makeStore({
+        sleep: (ms) => {
+          setSystemTime(new Date(Date.now() + ms));
+          return Promise.resolve();
+        },
+      });
+      await store.get('parts/0', { paced: true });
+      expect(calls).toHaveLength(4);
+      // The last attempt went 90 s after the first: its token must still have time left.
+      const token = new URL(String(calls.at(-1)?.url)).searchParams.get('token') ?? '';
+      const { exp } = JSON.parse(Buffer.from(token.split('.')[1] ?? '', 'base64url').toString('utf8')) as { exp: number };
+      expect(exp * 1000).toBeGreaterThan(Date.now());
+    } finally {
+      setSystemTime();
+    }
+  });
+
   it('without paced, a 429 is the typed error carrying retryAfterSec — and the old message', async () => {
     const { store, slept } = pacedStore(1, '7');
     const error = await store.get('parts/0').catch((e: unknown) => e);

package/src/server/storage/binaryStore.ts

@@ -728,7 +728,9 @@ export function createBinaryStore(cfg: BinaryStoreConfig): BinaryStore {
   const sendRead = async (
     op: string,
     key: string,
-    url: string,
+    /** Signs the URL. Called for EVERY attempt: a read token lives 60 s and a paced read may wait
+     *  120 s, so a URL signed once went out dead after the first long retry-after (forge task 3302). */
+    mint: () => Promise<string>,
     init: RequestInit | undefined,
     opts: ReadOptions | undefined,
   ): Promise<Response> => {
@@ -737,7 +739,7 @@ export function createBinaryStore(cfg: BinaryStoreConfig): BinaryStore {
       : 0;
     let waited = 0;
     for (let attempt = 0; ; attempt++) {
-      const res = await send(url, init);
+      const res = await send(await mint(), init);
       if (res.status !== 429) return res;
       const retryAfterSec = retryAfterSeconds(res.headers.get('retry-after'), attempt);
       const ms = retryAfterSec * 1000;
@@ -875,7 +877,7 @@ export function createBinaryStore(cfg: BinaryStoreConfig): BinaryStore {
       // short-circuit here — we want the bytes, and only the store has them.
       if (!opts?.fresh && knownAbsent(key)) return null;
       countWireRead(key);
-      const res = await sendRead('get', key, await internalMediaUrl(key), undefined, opts);
+      const res = await sendRead('get', key, () => internalMediaUrl(key), undefined, opts);
       if (res.status === 404) {
         rememberAbsent(key);
         return null;
@@ -952,7 +954,7 @@ export function createBinaryStore(cfg: BinaryStoreConfig): BinaryStore {
         if (knownAbsent(key)) return null;
       }
       countWireRead(key);
-      const res = await sendRead('meta', key, await metaUrl(key), undefined, opts);
+      const res = await sendRead('meta', key, () => metaUrl(key), undefined, opts);
       if (res.status === 404) {
         rememberAbsent(key);
         return null;
@@ -995,7 +997,7 @@ export function createBinaryStore(cfg: BinaryStoreConfig): BinaryStore {
         if (why instanceof BinaryStoreRateLimitedError) throw why;
       }
       countWireRead(key);
-      const res = await sendRead('stat', key, await internalMediaUrl(key), { headers: { Range: 'bytes=0-0' } }, opts);
+      const res = await sendRead('stat', key, () => internalMediaUrl(key), { headers: { Range: 'bytes=0-0' } }, opts);
       if (res.status === 404) {
         rememberAbsent(key);
         return null;