fix: port bb socket startup retry to next (#24960)

## Summary

Ports #24802 to
`next`.

This keeps the same behavior change from the merged v5 PR:
- bb.js native socket startup now waits while the bb process remains
alive, with a 60s wedged-process backstop instead of the old shared 5s
socket/connect deadline.
- bb startup failures are wrapped as retryable `ProvingError`s in
bb-prover.
- retryability is preserved when bb-prover re-wraps proof generation and
verification failures.

## Conflict resolution

The automatic cherry-pick conflicted because `barretenberg/ts/src/...`
on the source branch has moved to `barretenberg/ts/bb.js/src/...` on
`next`.

Resolved by adapting the socket backend changes into the `bb.js` path
and preserving `next`'s `createAsyncBackend` API shape, which returns
`IMsgpackBackendAsync` rather than constructing a `Barretenberg` wrapper
there. Added a small follow-up commit to satisfy the `next` lint rule
for `destroy()`.

Refs #24802

## Verification

- `git diff --check origin/next...HEAD`
- `yarn formatting:fix` in `barretenberg/ts/bb.js`
- `yarn test bb_backends/node/native_socket.test.ts --runInBand` in
`barretenberg/ts/bb.js`

Blocked locally:
- `./bootstrap.sh build` in `barretenberg/ts/bb.js` passed formatting,
then stopped at codegen because this checkout lacks
`barretenberg/cpp/build/bin/bb`.
- `JEST_MAX_WORKERS=1 yarn workspace @aztec/bb-prover test
src/bb/bb_js_backend.test.ts` could not complete in this cold checkout
without built workspace exports for `@aztec/bb.js`/`@aztec/foundation`.

---
*Created by
[claudebox](https://claudebox.work/v2/sessions/f03a66a010266d34/jobs/1)
· group: `slackbot` · [Slack
thread](https://aztecprotocol.slack.com/archives/C0AGN2WT3CP/p1784890226762699?thread_ts=1784890226.762699&cid=C0AGN2WT3CP)*

Author: PhilWindle

barretenberg/ts/bb.js/src/bb_backends/node/index.ts

@@ -26,7 +26,7 @@ export async function createAsyncBackend(
         throw new Error('Native backend requires bb binary.');
       }
       logger(`Using native Unix socket backend: ${bbPath}`);
-      return new BarretenbergNativeSocketAsyncBackend(bbPath, options.threads, options.logger, options.unref);
+      return await BarretenbergNativeSocketAsyncBackend.new(bbPath, options.threads, options.logger, options.unref);
     }
 
     case BackendType.NativeSharedMemory: {

barretenberg/ts/bb.js/src/bb_backends/node/native_socket.test.ts

@@ -0,0 +1,82 @@
+import { jest } from '@jest/globals';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+import { BarretenbergNativeSocketAsyncBackend } from './native_socket.js';
+
+jest.setTimeout(30_000);
+
+// Echo server speaking the bb msgpack socket protocol (4-byte LE length prefix), started after
+// an optional delay to simulate bb's startup time on a loaded machine.
+const ECHO_SERVER_JS = `
+const net = require('net');
+const socketPath = process.argv[2];
+const server = net.createServer(sock => {
+  let buf = Buffer.alloc(0);
+  sock.on('data', d => {
+    buf = Buffer.concat([buf, d]);
+    while (buf.length >= 4) {
+      const len = buf.readUInt32LE(0);
+      if (buf.length < 4 + len) break;
+      const payload = buf.subarray(4, 4 + len);
+      const out = Buffer.alloc(4);
+      out.writeUInt32LE(payload.length, 0);
+      sock.write(out);
+      sock.write(payload);
+      buf = buf.subarray(4 + len);
+    }
+  });
+});
+server.listen(socketPath);
+`;
+
+// A fake bb binary: a bash script that optionally sleeps, then runs the echo server on the
+// socket path bb receives via `msgpack run --input <path>` ($4).
+function writeFakeBb(startupDelaySecs: number): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'fake-bb-'));
+  const serverJs = path.join(dir, 'echo_server.cjs');
+  fs.writeFileSync(serverJs, ECHO_SERVER_JS);
+  const file = path.join(dir, 'bb');
+  const sleep = startupDelaySecs > 0 ? `sleep ${startupDelaySecs}\n` : '';
+  fs.writeFileSync(file, `#!/bin/bash\n${sleep}exec node ${serverJs} "$4"\n`, { mode: 0o755 });
+  return file;
+}
+
+function writeFakeBbScript(script: string): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'fake-bb-'));
+  const file = path.join(dir, 'bb');
+  fs.writeFileSync(file, script, { mode: 0o755 });
+  return file;
+}
+
+describe('BarretenbergNativeSocketAsyncBackend', () => {
+  it('connects and echoes when bb starts promptly', async () => {
+    const fakeBb = writeFakeBb(0);
+    const backend = await BarretenbergNativeSocketAsyncBackend.new(fakeBb);
+    const response = await backend.call(new Uint8Array([1, 2, 3, 4]));
+    expect(response).toEqual(new Uint8Array([1, 2, 3, 4]));
+    await backend.destroy();
+  });
+
+  it('connects even when bb takes longer than 5s to create its socket', async () => {
+    const fakeBb = writeFakeBb(7);
+    const backend = await BarretenbergNativeSocketAsyncBackend.new(fakeBb);
+    const response = await backend.call(new Uint8Array([42]));
+    expect(response).toEqual(new Uint8Array([42]));
+    await backend.destroy();
+  });
+
+  it('fails with the exit cause when bb dies before creating its socket', async () => {
+    const fakeBb = writeFakeBbScript(`#!/bin/bash\nexit 17\n`);
+    await expect(BarretenbergNativeSocketAsyncBackend.new(fakeBb)).rejects.toThrow(
+      /exited before socket connection was established \(code=17/,
+    );
+  });
+
+  it('fails with the spawn error when the bb binary does not exist', async () => {
+    await expect(BarretenbergNativeSocketAsyncBackend.new('/nonexistent/bb-binary')).rejects.toThrow(
+      /Native backend process error/,
+    );
+  });
+});