cursedbelt-server 4.40.3 → 4.40.4

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

@@ -86,6 +86,27 @@ export type Wrangler = (args: string[]) => {
  * line until 4.22.0.
  */
 export declare const wranglerArgv: (bun?: string) => string[];
+/**
+ * Run `argv` to completion with its stdout written to a FILE, never a pipe, and return what it
+ * wrote.
+ *
+ * 🔴 A Bun child that ends with `process.exit()` drops whatever of its stdout the pipe had not
+ * taken yet, at a 64 KiB boundary — and wrangler is a Bun child whenever `node` is not on PATH
+ * (`bun x` then runs it under Bun), which is every launchd job and the station's recovery
+ * backup. Measured 2026-10-01: desk's `rows` pages came back cut at exactly 655,360 and 786,432
+ * bytes (`JSON Parse error: Unterminated string`) on every run under a launchd PATH and never in
+ * a shell with nvm's node; roms' `battery_saves` was halved to 3-row pages and flix's `films`
+ * refused 50 times in its log. A page that was cut halved and retried until it fit in the pipe,
+ * so backups stayed green but did 80 wrangler calls where 31 do. A file has no buffer to drop.
+ */
+export declare function spawnToFile(argv: string[], options?: {
+    cwd?: string;
+    env?: Record<string, string | undefined>;
+}): {
+    code: number;
+    stdout: string;
+    stderr: string;
+};
 /** The real {@link Wrangler}: `bun x wrangler …` in `cwd`, with `env` added to this process's. */
 export declare function spawnWrangler(options: {
     cwd: string;

package/dist/server/d1/pullD1.js

@@ -44,7 +44,9 @@
  * below still refuses a load short of what was read.
  */
 import { Database } from 'bun:sqlite';
-import { existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 /** Which side a backup must read. Pure, so every branch is testable without a network. */
 export function chooseBackupSource(input) {
     if (input.fromFileFlag) {
@@ -112,17 +114,34 @@ export const PAGE_ROWS = 500;
  * line until 4.22.0.
  */
 export const wranglerArgv = (bun = process.execPath) => [bun, 'x', 'wrangler'];
+/**
+ * Run `argv` to completion with its stdout written to a FILE, never a pipe, and return what it
+ * wrote.
+ *
+ * 🔴 A Bun child that ends with `process.exit()` drops whatever of its stdout the pipe had not
+ * taken yet, at a 64 KiB boundary — and wrangler is a Bun child whenever `node` is not on PATH
+ * (`bun x` then runs it under Bun), which is every launchd job and the station's recovery
+ * backup. Measured 2026-10-01: desk's `rows` pages came back cut at exactly 655,360 and 786,432
+ * bytes (`JSON Parse error: Unterminated string`) on every run under a launchd PATH and never in
+ * a shell with nvm's node; roms' `battery_saves` was halved to 3-row pages and flix's `films`
+ * refused 50 times in its log. A page that was cut halved and retried until it fit in the pipe,
+ * so backups stayed green but did 80 wrangler calls where 31 do. A file has no buffer to drop.
+ */
+export function spawnToFile(argv, options = {}) {
+    const dir = mkdtempSync(join(tmpdir(), 'cursedbelt-spawn-'));
+    const out = join(dir, 'stdout');
+    try {
+        const r = Bun.spawnSync(argv, { cwd: options.cwd, env: options.env, stdout: Bun.file(out), stderr: 'pipe' });
+        const stdout = existsSync(out) ? readFileSync(out, 'utf8') : '';
+        return { code: r.exitCode ?? 1, stdout, stderr: r.stderr.toString() };
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+}
 /** The real {@link Wrangler}: `bun x wrangler …` in `cwd`, with `env` added to this process's. */
 export function spawnWrangler(options) {
-    return (args) => {
-        const r = Bun.spawnSync([...wranglerArgv(), ...args], {
-            cwd: options.cwd,
-            env: { ...process.env, ...options.env },
-            stdout: 'pipe',
-            stderr: 'pipe',
-        });
-        return { code: r.exitCode ?? 1, stdout: r.stdout.toString(), stderr: r.stderr.toString() };
-    };
+    return (args) => spawnToFile([...wranglerArgv(), ...args], { cwd: options.cwd, env: { ...process.env, ...options.env } });
 }
 /**
  * 🔴 Trailing NUL bytes off a `wrangler d1 export` file, in place. Returns how many were removed.
@@ -174,7 +193,14 @@ function execute(wrangler, database, sql) {
     const r = wrangler(['d1', 'execute', database, '--remote', '--env=', '--json', '--command', sql]);
     if (r.code !== 0)
         throw new Error(r.stderr.trim() || r.stdout.trim() || `wrangler exited ${r.code}`);
-    const parsed = JSON.parse(r.stdout.slice(r.stdout.indexOf('[')));
+    let parsed;
+    try {
+        parsed = JSON.parse(r.stdout.slice(r.stdout.indexOf('[')));
+    }
+    catch (error) {
+        // The byte count is the diagnosis: a multiple of 65,536 is a cut pipe (see `spawnToFile`).
+        throw new Error(`${error.message} (${r.stdout.length} bytes of stdout)`);
+    }
     return parsed.map((statement) => statement.results ?? []);
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "cursedbelt-server",
-	"version": "4.40.3",
+	"version": "4.40.4",
 	"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.",
@@ -353,7 +353,7 @@
 	"dependencies": {
 		"argon2id": "1.0.1",
 		"cursedbelt-core": "^2.1.1",
-		"cursedops": ">=0.8.1 <0.13.0",
+		"cursedops": ">=0.8.1 <0.14.0",
 		"cwip": "^4.6.0",
 		"jose": "^6.2.3"
 	},

package/src/server/d1/pullD1.spec.ts

@@ -12,7 +12,7 @@ import {
 	type Wrangler,
 	wranglerArgv,
 } from './localBackup.js';
-import { PAGE_ROWS, pageSql, tablePlan } from './pullD1.js';
+import { PAGE_ROWS, pageSql, spawnToFile, tablePlan } from './pullD1.js';
 
 const dirs: string[] = [];
 const scratch = (): string => {
@@ -58,7 +58,7 @@ describe('🔴 chooseBackupSource — the one whose failure looks like a green b
 
 describe('servedRuntime', () => {
 	const serve = (body: unknown, status = 200) =>
-		Bun.serve({ port: 0, fetch: () => Response.json(body, { status }) });
+		Bun.serve({ hostname: "127.0.0.1", port: 0, fetch: () => Response.json(body, { status }) });
 
 	test('reads `runtime` off /healthz', async () => {
 		const server = serve({ runtime: 'worker' });
@@ -361,6 +361,27 @@ END;`;
 		expect(wranglerArgv('/x/bun')).toEqual(['/x/bun', 'x', 'wrangler']);
 	});
 
+	test('🔴 spawnToFile keeps ALL of a Bun child\'s stdout — a pipe loses the tail at a 64 KiB boundary', async () => {
+		// wrangler under `bun x` with no node on PATH (every launchd job) is exactly this child.
+		const dir = scratch();
+		const child = join(dir, 'big.js');
+		writeFileSync(child, "process.stdout.write('[' + JSON.stringify('x'.repeat(2_000_000)) + ']'); process.exit(0);");
+		const proc = Bun.spawn([process.execPath, child], { stdout: 'pipe' });
+		const piped = (await new Response(proc.stdout).text()).length;
+		await proc.exited;
+		// The failure this exists for: if Bun ever stops cutting the pipe, this line says so.
+		expect(piped).toBeLessThan(2_000_004);
+		const r = spawnToFile([process.execPath, child]);
+		expect(r.code).toBe(0);
+		expect(r.stdout.length).toBe(2_000_004);
+		expect(JSON.parse(r.stdout)).toHaveLength(1);
+	});
+
+	test('a cut page names its byte count, so a 64 KiB multiple is visible in the log', async () => {
+		const cut: Wrangler = () => ({ code: 0, stdout: '[{"results":[{"name":"ite', stderr: '' });
+		await expect(pull(scratch(), cut)).rejects.toThrow(/\(25 bytes of stdout\)/);
+	});
+
 	test('🔴 a pull with no rows at all THROWS — never an empty library dated today', async () => {
 		await expect(pull(scratch(), d1(live()).run)).rejects.toThrow(/no rows/);
 	});

package/src/server/d1/pullD1.ts

@@ -45,7 +45,9 @@
  */
 
 import { Database } from 'bun:sqlite';
-import { existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 
 export type BackupSourceChoice = { kind: 'file' | 'd1' | 'refuse'; why: string };
 
@@ -132,17 +134,37 @@ export type Wrangler = (args: string[]) => { code: number; stdout: string; stder
  */
 export const wranglerArgv = (bun: string = process.execPath): string[] => [bun, 'x', 'wrangler'];
 
+/**
+ * Run `argv` to completion with its stdout written to a FILE, never a pipe, and return what it
+ * wrote.
+ *
+ * 🔴 A Bun child that ends with `process.exit()` drops whatever of its stdout the pipe had not
+ * taken yet, at a 64 KiB boundary — and wrangler is a Bun child whenever `node` is not on PATH
+ * (`bun x` then runs it under Bun), which is every launchd job and the station's recovery
+ * backup. Measured 2026-10-01: desk's `rows` pages came back cut at exactly 655,360 and 786,432
+ * bytes (`JSON Parse error: Unterminated string`) on every run under a launchd PATH and never in
+ * a shell with nvm's node; roms' `battery_saves` was halved to 3-row pages and flix's `films`
+ * refused 50 times in its log. A page that was cut halved and retried until it fit in the pipe,
+ * so backups stayed green but did 80 wrangler calls where 31 do. A file has no buffer to drop.
+ */
+export function spawnToFile(
+	argv: string[],
+	options: { cwd?: string; env?: Record<string, string | undefined> } = {},
+): { code: number; stdout: string; stderr: string } {
+	const dir = mkdtempSync(join(tmpdir(), 'cursedbelt-spawn-'));
+	const out = join(dir, 'stdout');
+	try {
+		const r = Bun.spawnSync(argv, { cwd: options.cwd, env: options.env, stdout: Bun.file(out), stderr: 'pipe' });
+		const stdout = existsSync(out) ? readFileSync(out, 'utf8') : '';
+		return { code: r.exitCode ?? 1, stdout, stderr: r.stderr.toString() };
+	} finally {
+		rmSync(dir, { recursive: true, force: true });
+	}
+}
+
 /** The real {@link Wrangler}: `bun x wrangler …` in `cwd`, with `env` added to this process's. */
 export function spawnWrangler(options: { cwd: string; env?: Record<string, string | undefined> }): Wrangler {
-	return (args) => {
-		const r = Bun.spawnSync([...wranglerArgv(), ...args], {
-			cwd: options.cwd,
-			env: { ...process.env, ...options.env },
-			stdout: 'pipe',
-			stderr: 'pipe',
-		});
-		return { code: r.exitCode ?? 1, stdout: r.stdout.toString(), stderr: r.stderr.toString() };
-	};
+	return (args) => spawnToFile([...wranglerArgv(), ...args], { cwd: options.cwd, env: { ...process.env, ...options.env } });
 }
 
 /**
@@ -216,7 +238,13 @@ const sqlText = (text: string): string => `'${text.replaceAll("'", "''")}'`;
 function execute(wrangler: Wrangler, database: string, sql: string): Array<Array<Record<string, unknown>>> {
 	const r = wrangler(['d1', 'execute', database, '--remote', '--env=', '--json', '--command', sql]);
 	if (r.code !== 0) throw new Error(r.stderr.trim() || r.stdout.trim() || `wrangler exited ${r.code}`);
-	const parsed = JSON.parse(r.stdout.slice(r.stdout.indexOf('['))) as Array<{ results?: Array<Record<string, unknown>> }>;
+	let parsed: Array<{ results?: Array<Record<string, unknown>> }>;
+	try {
+		parsed = JSON.parse(r.stdout.slice(r.stdout.indexOf('[')));
+	} catch (error) {
+		// The byte count is the diagnosis: a multiple of 65,536 is a cut pipe (see `spawnToFile`).
+		throw new Error(`${(error as Error).message} (${r.stdout.length} bytes of stdout)`);
+	}
 	return parsed.map((statement) => statement.results ?? []);
 }
 

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

@@ -131,9 +131,9 @@ describe('diskStore + serveRange', () => {
       await store.putStream('fs/tenant1/live.bin', body, 'application/octet-stream');
       return c.json({ ok: true });
     });
-    const server = Bun.serve({ fetch: app.fetch, port: 0 });
+    const server = Bun.serve({ hostname: "127.0.0.1", fetch: app.fetch, port: 0 });
     try {
-      const res = await fetch(`http://localhost:${server.port}/u`, {
+      const res = await fetch(`http://127.0.0.1:${server.port}/u`, {
         method: 'PUT',
         body: 'live request bytes',
       });