@oh-my-pi/pi-utils 6.8.0 → 6.8.1

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-utils",
-	"version": "6.8.0",
+	"version": "6.8.1",
 	"description": "Shared utilities for pi packages",
 	"type": "module",
 	"main": "./src/index.ts",

package/src/abortable.ts

@@ -5,9 +5,8 @@ export class AbortError extends Error {
 		assert(signal.aborted, "Abort signal must be aborted");
 
 		const message = signal.reason instanceof Error ? signal.reason.message : "Cancelled";
-		super(`Aborted: ${message}`, { cause: message });
+		super(`Aborted: ${message}`, { cause: signal.reason });
 		this.name = "AbortError";
-		this.cause = signal.reason;
 	}
 }
 
@@ -42,9 +41,11 @@ export function createAbortablePromise<T>(signal?: AbortSignal): {
 		reject(new AbortError(signal));
 	};
 	signal.addEventListener("abort", abortHandler, { once: true });
-	promise.finally(() => {
-		signal.removeEventListener("abort", abortHandler);
-	});
+	promise
+		.finally(() => {
+			signal.removeEventListener("abort", abortHandler);
+		})
+		.catch(() => {});
 	return { promise, resolve, reject };
 }
 
@@ -63,7 +64,20 @@ export function untilAborted<T>(signal: AbortSignal | undefined | null, pr: () =
 		return Promise.reject(new AbortError(signal));
 	}
 	const { promise, resolve, reject } = createAbortablePromise<T>(signal);
-	pr().then(resolve, reject);
+	let settled = false;
+	const wrappedResolve = (value: T | PromiseLike<T>) => {
+		if (!settled) {
+			settled = true;
+			resolve(value);
+		}
+	};
+	const wrappedReject = (reason?: unknown) => {
+		if (!settled) {
+			settled = true;
+			reject(reason);
+		}
+	};
+	pr().then(wrappedResolve, wrappedReject);
 	return promise;
 }
 

package/src/postmortem.ts

@@ -6,6 +6,7 @@
  * allow reliably releasing resources or shutting down subprocesses, files, sockets, etc.
  */
 
+import { isMainThread } from "node:worker_threads";
 import { logger } from ".";
 
 // Cleanup reasons, in order of priority/meaning.
@@ -45,7 +46,8 @@ function runCleanup(reason: Reason): Promise<void> {
 
 	// Call .cleanup() for each callback that is still "armed".
 	// Use Promise.try to handle sync/async, but only those armed.
-	const promises = callbackList.reverse().map((callback) => {
+	// Create a copy to avoid mutating the original array with reverse()
+	const promises = [...callbackList].reverse().map((callback) => {
 		return Promise.try(() => callback(reason));
 	});
 
@@ -61,33 +63,45 @@ function runCleanup(reason: Reason): Promise<void> {
 }
 
 // Register signal and error event handlers to trigger cleanup before exit.
-process
-	.on("SIGINT", async () => {
-		await runCleanup(Reason.SIGINT);
-		process.exit(130); // 128 + SIGINT (2)
-	})
-	.on("uncaughtException", async (err) => {
-		logger.error("Uncaught exception", { err, stack: err.stack });
-		await runCleanup(Reason.UNCAUGHT_EXCEPTION);
-		process.exit(1);
-	})
-	.on("unhandledRejection", async (reason) => {
-		const err = reason instanceof Error ? reason : new Error(String(reason));
-		logger.error("Unhandled rejection", { err, stack: err.stack });
-		await runCleanup(Reason.UNHANDLED_REJECTION);
-		process.exit(1);
-	})
-	.on("exit", async () => {
-		void runCleanup(Reason.EXIT); // fire and forget (exit imminent)
-	})
-	.on("SIGTERM", async () => {
-		await runCleanup(Reason.SIGTERM);
-		process.exit(143); // 128 + SIGTERM (15)
-	})
-	.on("SIGHUP", async () => {
-		await runCleanup(Reason.SIGHUP);
-		process.exit(129); // 128 + SIGHUP (1)
+// Main thread: full signal handling (SIGINT, SIGTERM, SIGHUP) + exceptions + exit
+// Worker thread: exit only (workers use self.addEventListener for exceptions)
+if (isMainThread) {
+	process
+		.on("SIGINT", async () => {
+			await runCleanup(Reason.SIGINT);
+			process.exit(130); // 128 + SIGINT (2)
+		})
+		.on("uncaughtException", async (err) => {
+			logger.error("Uncaught exception", { err, stack: err.stack });
+			await runCleanup(Reason.UNCAUGHT_EXCEPTION);
+			process.exit(1);
+		})
+		.on("unhandledRejection", async (reason) => {
+			const err = reason instanceof Error ? reason : new Error(String(reason));
+			logger.error("Unhandled rejection", { err, stack: err.stack });
+			await runCleanup(Reason.UNHANDLED_REJECTION);
+			process.exit(1);
+		})
+		.on("exit", async () => {
+			void runCleanup(Reason.EXIT); // fire and forget (exit imminent)
+		})
+		.on("SIGTERM", async () => {
+			await runCleanup(Reason.SIGTERM);
+			process.exit(143); // 128 + SIGTERM (15)
+		})
+		.on("SIGHUP", async () => {
+			await runCleanup(Reason.SIGHUP);
+			process.exit(129); // 128 + SIGHUP (1)
+		});
+} else {
+	// Worker thread: only register exit handler for cleanup.
+	// DO NOT register uncaughtException/unhandledRejection handlers here -
+	// they would swallow errors before the worker's own handlers (self.addEventListener)
+	// can report failures back to the parent thread.
+	process.on("exit", () => {
+		void runCleanup(Reason.EXIT);
 	});
+}
 
 /**
  * Register a process cleanup callback, to be run on shutdown, signal, or fatal error.
@@ -134,10 +148,26 @@ export function register(id: string, callback: (reason: Reason) => void | Promis
 }
 
 /**
- * Runs all cleanup callbacks and exits the process.
+ * Runs all cleanup callbacks without exiting.
+ * Use this in workers or when you need to clean up but continue execution.
+ */
+export function cleanup(): Promise<void> {
+	return runCleanup(Reason.MANUAL);
+}
+
+/**
+ * Runs all cleanup callbacks and exits.
+ *
+ * In main thread: waits for stdout drain, then calls process.exit().
+ * In workers: runs cleanup only (process.exit would kill entire process).
  */
 export async function quit(code: number = 0): Promise<void> {
 	await runCleanup(Reason.MANUAL);
+
+	if (!isMainThread) {
+		return; // Workers: cleanup done, let worker exit naturally
+	}
+
 	if (process.stdout.writableLength > 0) {
 		const { promise, resolve } = Promise.withResolvers<void>();
 		process.stdout.once("drain", resolve);

package/src/ptree.ts

@@ -201,7 +201,14 @@ export class ChildProcess {
 	async killAndWait(): Promise<void> {
 		// Try killing with SIGTERM, then SIGKILL if it doesn't exit within 1 second
 		this.kill("SIGTERM");
-		await Promise.race([this.exited, Bun.sleep(1000).then(() => this.kill("SIGKILL"))]);
+		const exitedOrTimeout = await Promise.race([
+			this.exited.then(() => "exited" as const),
+			Bun.sleep(1000).then(() => "timeout" as const),
+		]);
+		if (exitedOrTimeout === "timeout") {
+			this.kill("SIGKILL");
+			await this.exited.catch(() => {});
+		}
 	}
 
 	// Output utilities (aliases for easy chaining)
@@ -329,7 +336,7 @@ export class AbortError extends Exception {
  */
 export class TimeoutError extends AbortError {
 	constructor(timeout: number, stderr: string) {
-		super(new Error(`Process timed out after ${timeout}ms`), stderr);
+		super(new Error(`Timed out after ${Math.round(timeout / 1000)}s`), stderr);
 	}
 }