cursedbelt-server 4.41.0 → 4.42.0

package/dist/server/d1/http.d.ts

@@ -51,7 +51,26 @@ export interface HttpD1Options {
     fetch?: typeof fetch;
     /** Defaults to `https://api.cloudflare.com/client/v4`. */
     apiBase?: string;
+    /**
+     * The waits, in ms, before each retry of a request that never CONNECTED — see
+     * {@link neverConnected}. Default {@link CONNECT_RETRY_DELAYS_MS}; `[]` fails on the first.
+     */
+    connectRetryDelaysMs?: readonly number[];
+    /** Injected for tests. Defaults to a `setTimeout` promise. */
+    sleep?: (ms: number) => Promise<void>;
 }
+/**
+ * ~1m45s of waiting, which outlasts a Mac's network coming back after a wake. Measured
+ * 2026-10-02 16:15Z: family's once-a-day `dangling-media` job fired as the Mac woke, its first
+ * D1 read was `ConnectionRefused`, and the job exited 1 — red for a whole day over one blip.
+ */
+export declare const CONNECT_RETRY_DELAYS_MS: readonly number[];
+/**
+ * 🔴 `true` only for a failure that happened BEFORE the request reached Cloudflare — refused,
+ * unresolvable, unroutable — so retrying it cannot run a write twice. A reset or a timeout
+ * after connecting may have executed the statement, and is thrown as it is.
+ */
+export declare function neverConnected(err: unknown): boolean;
 /** Thrown when the REST API itself refuses — auth, a missing database, a rate limit. */
 export declare class D1HttpError extends Error {
     readonly status: number;

package/dist/server/d1/http.js

@@ -40,6 +40,22 @@
  */
 import { createRemoteD1 } from './remote.js';
 import { D1UnsupportedError } from './types.js';
+/**
+ * ~1m45s of waiting, which outlasts a Mac's network coming back after a wake. Measured
+ * 2026-10-02 16:15Z: family's once-a-day `dangling-media` job fired as the Mac woke, its first
+ * D1 read was `ConnectionRefused`, and the job exited 1 — red for a whole day over one blip.
+ */
+export const CONNECT_RETRY_DELAYS_MS = [2_000, 10_000, 30_000, 60_000];
+/**
+ * 🔴 `true` only for a failure that happened BEFORE the request reached Cloudflare — refused,
+ * unresolvable, unroutable — so retrying it cannot run a write twice. A reset or a timeout
+ * after connecting may have executed the statement, and is thrown as it is.
+ */
+export function neverConnected(err) {
+    const code = err?.code;
+    return (typeof code === 'string' &&
+        ['ConnectionRefused', 'ECONNREFUSED', 'ENOTFOUND', 'EAI_AGAIN', 'FailedToOpenSocket', 'ENETUNREACH', 'EHOSTUNREACH', 'ENETDOWN'].includes(code));
+}
 /** Thrown when the REST API itself refuses — auth, a missing database, a rate limit. */
 export class D1HttpError extends Error {
     status;
@@ -65,13 +81,28 @@ export function httpD1Binding(options) {
     const doFetch = options.fetch ?? fetch;
     const base = `${options.apiBase ?? 'https://api.cloudflare.com/client/v4'}/accounts/${options.accountId}/d1/database/${options.databaseId}`;
     const timeoutMs = options.timeoutMs ?? 30_000;
+    const retryDelays = options.connectRetryDelaysMs ?? CONNECT_RETRY_DELAYS_MS;
+    const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    const send = async (path, body) => {
+        for (let attempt = 0;; attempt++) {
+            try {
+                return await doFetch(`${base}${path}`, {
+                    method: 'POST',
+                    headers: { authorization: `Bearer ${options.apiToken}`, 'content-type': 'application/json' },
+                    body: JSON.stringify(body),
+                    signal: AbortSignal.timeout(timeoutMs),
+                });
+            }
+            catch (err) {
+                const wait = retryDelays[attempt];
+                if (wait === undefined || !neverConnected(err))
+                    throw err;
+                await sleep(wait);
+            }
+        }
+    };
     const post = async (path, body) => {
-        const response = await doFetch(`${base}${path}`, {
-            method: 'POST',
-            headers: { authorization: `Bearer ${options.apiToken}`, 'content-type': 'application/json' },
-            body: JSON.stringify(body),
-            signal: AbortSignal.timeout(timeoutMs),
-        });
+        const response = await send(path, body);
         const envelope = (await response.json().catch(() => null));
         if (!response.ok || !envelope || envelope.success === false) {
             const message = envelope?.errors

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "cursedbelt-server",
-	"version": "4.41.0",
+	"version": "4.42.0",
 	"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/d1/http.spec.ts

@@ -124,3 +124,46 @@ describe('createHttpD1', () => {
 		expect(sent[0]?.body).toEqual({ sql: 'CREATE TABLE u (x); INSERT INTO u VALUES (1); INSERT INTO u VALUES (2)' });
 	});
 });
+
+describe('🔴 a request that never connected is retried; one that may have run is not', () => {
+	const refused = () => Object.assign(new TypeError('Unable to connect. Is the computer able to access the url?'), { code: 'ConnectionRefused' });
+	const flaky = (failures: Error[]) => {
+		let calls = 0;
+		const waits: number[] = [];
+		const fetchImpl = (async () => {
+			const fail = failures[calls++];
+			if (fail) throw fail;
+			return new Response(JSON.stringify({ success: true, errors: [], result: [{ results: [{ n: 1 }], success: true }] }));
+		}) as unknown as typeof fetch;
+		const db = createHttpD1({ accountId: 'a', databaseId: 'd', apiToken: 't', fetch: fetchImpl, sleep: async (ms) => void waits.push(ms) });
+		return { db, waits, calls: () => calls };
+	};
+
+	test('2026-10-02, family dangling-media: ConnectionRefused on a wake, then the network is back — the read answers', async () => {
+		const { db, waits, calls } = flaky([refused(), refused()]);
+		expect(await db.prepare('SELECT 1 n').first('n')).toBe(1);
+		expect(calls()).toBe(3);
+		expect(waits).toEqual([2_000, 10_000]);
+	});
+
+	test('still refused after every wait: the original error, not a swallowed one', async () => {
+		const { db, waits } = flaky(Array.from({ length: 5 }, refused));
+		await expect(db.prepare('SELECT 1').all()).rejects.toThrow('Unable to connect');
+		expect(waits).toEqual([2_000, 10_000, 30_000, 60_000]);
+	});
+
+	test('a reset after connecting may have run the write — thrown at once, never retried', async () => {
+		const reset = Object.assign(new TypeError('socket closed'), { code: 'ECONNRESET' });
+		const { db, calls } = flaky([reset]);
+		await expect(db.prepare('INSERT INTO t VALUES (1)').run()).rejects.toThrow('socket closed');
+		expect(calls()).toBe(1);
+	});
+
+	test('an unresolvable host is a never-connected failure too, and a timeout is not', async () => {
+		const dns = Object.assign(new TypeError('getaddrinfo ENOTFOUND api.cloudflare.com'), { code: 'ENOTFOUND' });
+		expect(await flaky([dns]).db.prepare('SELECT 1 n').first('n')).toBe(1);
+		const timeout = flaky([new DOMException('The operation timed out.', 'TimeoutError')]);
+		await expect(timeout.db.prepare('SELECT 1').all()).rejects.toThrow('timed out');
+		expect(timeout.calls()).toBe(1);
+	});
+});

package/src/server/d1/http.ts

@@ -53,6 +53,33 @@ export interface HttpD1Options {
 	fetch?: typeof fetch;
 	/** Defaults to `https://api.cloudflare.com/client/v4`. */
 	apiBase?: string;
+	/**
+	 * The waits, in ms, before each retry of a request that never CONNECTED — see
+	 * {@link neverConnected}. Default {@link CONNECT_RETRY_DELAYS_MS}; `[]` fails on the first.
+	 */
+	connectRetryDelaysMs?: readonly number[];
+	/** Injected for tests. Defaults to a `setTimeout` promise. */
+	sleep?: (ms: number) => Promise<void>;
+}
+
+/**
+ * ~1m45s of waiting, which outlasts a Mac's network coming back after a wake. Measured
+ * 2026-10-02 16:15Z: family's once-a-day `dangling-media` job fired as the Mac woke, its first
+ * D1 read was `ConnectionRefused`, and the job exited 1 — red for a whole day over one blip.
+ */
+export const CONNECT_RETRY_DELAYS_MS: readonly number[] = [2_000, 10_000, 30_000, 60_000];
+
+/**
+ * 🔴 `true` only for a failure that happened BEFORE the request reached Cloudflare — refused,
+ * unresolvable, unroutable — so retrying it cannot run a write twice. A reset or a timeout
+ * after connecting may have executed the statement, and is thrown as it is.
+ */
+export function neverConnected(err: unknown): boolean {
+	const code = (err as { code?: unknown } | null)?.code;
+	return (
+		typeof code === 'string' &&
+		['ConnectionRefused', 'ECONNREFUSED', 'ENOTFOUND', 'EAI_AGAIN', 'FailedToOpenSocket', 'ENETUNREACH', 'EHOSTUNREACH', 'ENETDOWN'].includes(code)
+	);
 }
 
 interface WireResult {
@@ -97,14 +124,28 @@ export function httpD1Binding(options: HttpD1Options): D1BindingLike {
 	const doFetch = options.fetch ?? fetch;
 	const base = `${options.apiBase ?? 'https://api.cloudflare.com/client/v4'}/accounts/${options.accountId}/d1/database/${options.databaseId}`;
 	const timeoutMs = options.timeoutMs ?? 30_000;
+	const retryDelays = options.connectRetryDelaysMs ?? CONNECT_RETRY_DELAYS_MS;
+	const sleep = options.sleep ?? ((ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms)));
+
+	const send = async (path: '/query' | '/raw', body: unknown): Promise<Response> => {
+		for (let attempt = 0; ; attempt++) {
+			try {
+				return await doFetch(`${base}${path}`, {
+					method: 'POST',
+					headers: { authorization: `Bearer ${options.apiToken}`, 'content-type': 'application/json' },
+					body: JSON.stringify(body),
+					signal: AbortSignal.timeout(timeoutMs),
+				});
+			} catch (err) {
+				const wait = retryDelays[attempt];
+				if (wait === undefined || !neverConnected(err)) throw err;
+				await sleep(wait);
+			}
+		}
+	};
 
 	const post = async (path: '/query' | '/raw', body: unknown): Promise<WireResult[]> => {
-		const response = await doFetch(`${base}${path}`, {
-			method: 'POST',
-			headers: { authorization: `Bearer ${options.apiToken}`, 'content-type': 'application/json' },
-			body: JSON.stringify(body),
-			signal: AbortSignal.timeout(timeoutMs),
-		});
+		const response = await send(path, body);
 		const envelope = (await response.json().catch(() => null)) as Envelope | null;
 		if (!response.ok || !envelope || envelope.success === false) {
 			const message =