@abide/abide 0.33.0 → 0.33.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # abide
 
+## 0.33.1
+
+### Patch Changes
+
+- [`e9fb88f`](https://github.com/briancray/abide/commit/e9fb88f517d9c7eac24044a6b65f473263525a6e) - keep a wedged dev orchestrator from orphaning the server on the port ([`a29800d`](https://github.com/briancray/abide/commit/a29800d76300ff4d1c99a4d27dc790562a4af57b))
+
 ## 0.33.0
 
 ### Minor Changes

package/bin/abide.ts

@@ -36,8 +36,11 @@ handler the parent's default action kills it instantly — abandoning the
 `await child.exited` and orphaning the child, which (for a server) can then
 linger holding the port. Forwarding the signal and awaiting the child's exit
 (with a SIGKILL watchdog for a wedged child) guarantees the child is reaped
-before the parent leaves. Mirrors the child's exit code so callers and CI see
-the real result.
+before the parent leaves. SIGHUP (terminal close) is forwarded too: if Bun
+spawns the child in its own process group the kernel's terminal-close signal
+never reaches it, so the child only learns to shut down by this relay — without
+it a closed terminal orphans the child on the port. Mirrors the child's exit
+code so callers and CI see the real result.
 */
 async function runChild(cmd: string[]): Promise<never> {
     const child = Bun.spawn({ cmd, cwd, stdio: ['inherit', 'inherit', 'inherit'] })
@@ -47,6 +50,7 @@ async function runChild(cmd: string[]): Promise<never> {
     }
     process.on('SIGINT', () => forward('SIGINT'))
     process.on('SIGTERM', () => forward('SIGTERM'))
+    process.on('SIGHUP', () => forward('SIGHUP'))
     process.exit(await child.exited)
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@abide/abide",
-    "version": "0.33.0",
+    "version": "0.33.1",
     "type": "module",
     "sideEffects": false,
     "description": "Isomorphic multimodal HTTP framework built for humans and machines in a single Bun runtime",

package/src/devEntry.ts

@@ -81,7 +81,18 @@ function spawnWorker(port: number): { proc: Subprocess; ready: Promise<void> } {
     const proc = Bun.spawn({
         cmd: ['bun', '--preload', PRELOAD, SERVER_ENTRY],
         cwd,
-        env: { ...process.env, PORT: String(port), ABIDE_DEV: '1' },
+        /*
+        ABIDE_PARENT_PID activates serverEntry's exitWithParent watchdog: the
+        worker polls this orchestrator and self-exits if it dies abruptly
+        (kill -9, OOM) without running its shutdown handlers, so a wedged
+        orchestrator can't leave the worker orphaned holding the dev port.
+        */
+        env: {
+            ...process.env,
+            PORT: String(port),
+            ABIDE_DEV: '1',
+            ABIDE_PARENT_PID: String(process.pid),
+        },
         stdio: ['inherit', 'inherit', 'inherit'],
         // The child's POST /__abide/reload route signals a rebuild over IPC, so the
         // trigger rides the app's own port instead of a side channel.

package/src/lib/bundle/exitWithParent.ts

@@ -1,12 +1,12 @@
 /*
-Tie the embedded server's lifetime to the bundle launcher's.
+Tie this server's lifetime to its launcher's.
 
-The launcher spawns this server with ABIDE_PARENT_PID set to its own pid. On a
-clean window close the launcher reaps the child directly, but a force-quit (or
-crash) of the launcher can't run that cleanup, which would leave the server
-orphaned and holding its port. So when that env var is present, poll the parent
-and exit once it's gone. A no-op when the var is absent (standalone `abide
-start`), so it only ever activates inside a bundle.
+The launcher (a bundle, or the dev orchestrator) spawns this server with
+ABIDE_PARENT_PID set to its own pid. On a clean shutdown the launcher reaps the
+child directly, but a force-quit or crash of the launcher can't run that
+cleanup, which would leave the server orphaned and holding its port. So when
+that env var is present, poll the parent and exit once it's gone. A no-op when
+the var is absent (standalone `abide start`).
 */
 export function exitWithParent(): void {
     const parent = process.env.ABIDE_PARENT_PID