fix(@probitas/probitas): prevent BadResource error in subprocess HTTP/2 cleanup

Subprocess execution with HTTP/2 clients was causing "BadResource: Bad
resource ID" errors from node:http2 due to premature IPC connection closure
during active HTTP/2 stream finalization.

The issue occurred because:
1. IpcConnection.close() did not await writer.close(), abandoning pending writes
2. Parent process closed IPC before subprocess completed cleanup
3. Subprocess exited immediately without giving HTTP/2 sessions time to finalize

Fixed by:
- Making IpcConnection.close() async and awaiting writer.close()
- Awaiting closeIpc() calls in subprocess templates
- Reordering parent cleanup to wait for subprocess exit before closing IPC
- Adding 100ms grace period before subprocess exit for resource cleanup

This ensures HTTP/2 sessions can properly close their streams before the
underlying TCP connection is terminated.

Author: lambdalisue

src/cli/_templates/list.ts

@@ -77,12 +77,13 @@ async function main(): Promise<void> {
       console.error("Subprocess error:", error);
     }
   } finally {
-    closeIpc(ipc);
+    // Await close to ensure all pending writes are flushed
+    await closeIpc(ipc);
   }
 }
 
 // Run main and exit explicitly to avoid async operations keeping process alive
 main().finally(() => {
-  // Ensure process exits after output is flushed
-  setTimeout(() => Deno.exit(0), 0);
+  // Give resources time to clean up properly
+  setTimeout(() => Deno.exit(0), 100);
 });

src/cli/_templates/run.ts

@@ -149,12 +149,15 @@ async function main(): Promise<void> {
       console.error("Subprocess error:", error);
     }
   } finally {
-    closeIpc(ipc);
+    // Await close to ensure all pending writes are flushed
+    await closeIpc(ipc);
   }
 }
 
 // Run main and exit explicitly to avoid LogTape keeping process alive
 main().finally(() => {
-  // Ensure process exits after output is flushed
-  setTimeout(() => Deno.exit(0), 0);
+  // Give HTTP/2 and other resources time to clean up properly.
+  // This prevents "BadResource: Bad resource ID" errors from node:http2
+  // that occur when connections are closed while HTTP/2 streams are active.
+  setTimeout(() => Deno.exit(0), 100);
 });

src/cli/_templates/utils.ts

@@ -30,8 +30,8 @@ export interface IpcConnection {
   writer: WritableStreamDefaultWriter<Uint8Array>;
   /** Text encoder for converting strings to bytes */
   encoder: TextEncoder;
-  /** Close the underlying TCP connection */
-  close: () => void;
+  /** Close the underlying TCP connection (async to properly flush writes) */
+  close: () => Promise<void>;
 }
 
 /**
@@ -77,11 +77,12 @@ export async function connectIpc(port: number): Promise<IpcConnection> {
     readable,
     writer,
     encoder: new TextEncoder(),
-    close: () => {
+    close: async () => {
       try {
-        writer.close();
+        // Await writer.close() to ensure all pending writes are flushed
+        await writer.close();
       } catch {
-        // Already closed
+        // Already closed or errored
       }
       try {
         conn.close();
@@ -136,6 +137,6 @@ export async function writeOutput(
  *
  * @param ipc - IPC connection to close
  */
-export function closeIpc(ipc: IpcConnection): void {
-  ipc.close();
+export async function closeIpc(ipc: IpcConnection): Promise<void> {
+  await ipc.close();
 }

src/cli/commands/list.ts

@@ -272,9 +272,11 @@ async function runListSubprocess(
 
     throw new Error("Subprocess ended without sending result");
   } finally {
+    // Wait for subprocess to exit first to allow proper cleanup.
+    // This prevents closing IPC while the subprocess is still writing.
+    await proc.status;
     ipc.close();
     listener.close();
-    await proc.status;
     // Clean up temporary directory
     await Deno.remove(tempDir, { recursive: true }).catch(() => {});
   }

src/cli/commands/run.ts

@@ -334,9 +334,12 @@ async function runWithSubprocess(
 
     throw new Error("Subprocess ended without sending result");
   } finally {
+    // Wait for subprocess to exit first to allow proper cleanup.
+    // This prevents closing IPC while the subprocess is still writing,
+    // which could cause "BadResource: Bad resource ID" errors.
+    await proc.status;
     ipc.close();
     listener.close();
-    await proc.status;
     // Clean up temporary directory
     await Deno.remove(tempDir, { recursive: true }).catch(() => {});
   }