@zukhruf/shutdown 0.0.0-stage → 0.6.13

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ezzabuzaid
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,170 @@
-# Temporary Holding Version
+# @zukhruf/shutdown
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A graceful shutdown for a Node.js program. When the user presses Ctrl-C, or Docker stops the container, the program does not end at once. Its work stops when the signal aborts, its cleanup runs, and then the process ends by the same termination signal. Thus the shell, Docker or Kubernetes sees an interrupted process, not a process that completed its work. The package has no dependencies.
+
+The words in these documents have one meaning each. See the glossary in [CONTEXT.md](./CONTEXT.md).
+
+## Stop the work at a termination signal
+
+Make one `Shutdown` at the start of the entry point, before the first `await`. Then a termination signal during the start also stops the work. Give the signal to the work:
+
+```ts
+import { Shutdown } from '@zukhruf/shutdown';
+
+using shutdown = new Shutdown();
+using warehouse = new Warehouse('credits.sqlite');
+await pipeline.run({ signal: shutdown.signal });
+```
+
+The user presses Ctrl-C while the pipeline runs. Then:
+
+1. The signal aborts. Its reason is a `DOMException` with the name `AbortError` and the message `The process received SIGINT`.
+2. The pipeline stops at its next check of the signal, and `run()` returns.
+3. The `using` scopes end in reverse order: `warehouse` closes, then `shutdown`.
+4. The event loop has no more work. Node.js emits `'exit'`.
+5. The package removes each listener for SIGINT and sends SIGINT to its own process. The process dies by SIGINT.
+
+SIGINT, SIGTERM and SIGHUP start a shutdown. SIGQUIT does not: Ctrl-\ keeps its default action, which ends the process and writes a core dump.
+
+## What the parent sees
+
+| Cause of the shutdown                          | Exit status                                          |
+| ---------------------------------------------- | ---------------------------------------------------- |
+| A termination signal                           | The process dies by that signal                      |
+| A termination signal, and the process is PID 1 | Exit code 128 + the number of the signal (143)       |
+| A crash                                        | Exit code 1, or the exit code the program set        |
+| No stop request                                | The exit code of the program, as without the package |
+
+An exit code of 130 is not the same as a death by SIGINT. A Bash script stops its loop only when the child died by SIGINT. In a terminal, `node app.js && next` runs `next` after Ctrl-C when `app.js` exits with 0. When `app.js` dies by SIGINT, zsh stops the whole line. A parent that calls `waitpid()` sees the difference too: Node.js gives `signal: 'SIGINT'`, not `code: 130`.
+
+## A second stop request
+
+The first stop request removes the termination signal listeners of the package. Thus a second termination signal gets the default action, and the process ends at once. Use this when the cleanup does not end. For example, a read from a pipe that no program writes waits in the thread pool of Node.js, and no signal can stop it. The second Ctrl-C ends the process.
+
+The package has no timer. The supervisor owns the deadline of a shutdown:
+
+| Supervisor | Deadline                                             |
+| ---------- | ---------------------------------------------------- |
+| A terminal | The user presses Ctrl-C again                        |
+| Docker     | 10 s, then SIGKILL (`stop_grace_period` in Compose)  |
+| Kubernetes | 30 s, then SIGKILL (`terminationGracePeriodSeconds`) |
+| systemd    | 90 s, then SIGKILL (`TimeoutStopSec`)                |
+| Nx         | 5 s, then SIGKILL (`NX_PROCESS_KILL_GRACE_PERIOD`)   |
+
+## A crash
+
+A crash is an exception that no code catches, or a rejection that no code handles. Without the package, Node.js writes the error and ends the process at once. With the package, a crash is a stop request:
+
+1. The package writes the error to standard error.
+2. The signal aborts. Its reason is the error of the crash.
+3. The work stops, and the cleanup runs, as for a termination signal.
+4. The process exits with code 1.
+
+A second crash gets the default of Node.js: it writes the error and ends the process at once. A termination signal after the crash also ends the process at once.
+
+The exit status always follows the cause. A crash during the cleanup of a SIGINT shutdown ends the process at once, and the process dies by SIGINT. For this case the package keeps its crash listeners after a termination signal: it writes the error, and then it sends SIGINT to its own process. The default of Node.js cannot do it, because Node.js emits `'exit'` before it writes the error of a crash.
+
+## Stop at the end of a scope
+
+When the `using` scope of a `Shutdown` ends, the package removes its listeners and aborts the signal. Its reason is a `DOMException` with the name `AbortError` and the message `The shutdown scope ended`. This is not a stop request: the process does not die by a termination signal. After this, a termination signal gets the default action, and a crash gets the default of Node.js.
+
+A stop request that came before the end of the scope stays. Then the end of the scope removes no listener, and the process still ends by its cause.
+
+## Run in a container
+
+When the image starts the program with `CMD ["node", "main.js"]`, Node.js is PID 1. The kernel does not apply the default action of a signal to PID 1, so the process cannot die by the termination signal. Then the package sets the exit code to 128 + the number of the signal. Docker reports `Exited (143)` for SIGTERM.
+
+Give the container an init process to make the process die by the signal:
+
+```yaml
+services:
+  app:
+    image: app
+    init: true
+    stop_grace_period: 10s
+```
+
+With `init: true`, tini is PID 1. The program dies by the signal, and tini gives that exit status to Docker.
+
+## Stop an HTTP server
+
+The package does not stop a server. Node.js does most of it. An `http.Server` is `AsyncDisposable`, and `server.close()` stops new connections and closes the idle ones:
+
+```ts
+import { aborted } from 'node:util';
+
+import { Shutdown } from '@zukhruf/shutdown';
+
+using shutdown = new Shutdown();
+await using server = serve({ fetch: app.fetch, port });
+await aborted(shutdown.signal, server);
+setTimeout(() => server.closeAllConnections(), 1_000).unref();
+```
+
+`util.aborted()` also settles when the signal aborted before the call. `events.once(signal, 'abort')` does not.
+
+A probe on Node.js 26.10.0 compared this with `stoppable`, which `@godaddy/terminus` uses:
+
+| Case                             | `stoppable` (grace 1000 ms) | `await using server` | With `closeAllConnections()` after 1 s |
+| -------------------------------- | --------------------------- | -------------------- | -------------------------------------- |
+| An idle keep-alive connection    | 0 ms                        | 0 ms                 | 0 ms                                   |
+| A request that answers in 300 ms | 251 ms                      | 6254 ms              | 1001 ms                                |
+| A request that does not answer   | 1001 ms                     | open after 3000 ms   | 1001 ms                                |
+| A new client after the stop      | refused                     | refused              | refused                                |
+
+Node.js keeps a connection that becomes idle after the call to `close()` until `keepAliveTimeout` (5000 ms). It keeps a request that does not answer until `requestTimeout` (300 s). A server that must close faster needs a drainer that ends each connection after its last response, as `stoppable` does.
+
+## What the package does not do
+
+- Stop an HTTP server, or make a health check answer 503 during a shutdown. Node.js and the HTTP framework do these. See [Stop an HTTP server](#stop-an-http-server).
+- Run cleanup hooks. `using`, `await using` and `AsyncDisposableStack` run the cleanup, in reverse order.
+- Stop the work for other causes. `AbortSignal.any([shutdown.signal, failed.signal])` gives a signal that also aborts when the program stops itself.
+- Set a deadline. The supervisor sets it.
+- Stop child processes. `@zukhruf/coprocess` stops them.
+- A choice of termination signals. A program that must live on after its terminal closes runs under a supervisor or in tmux, not under `nohup`: a listener for SIGHUP replaces the ignore of `nohup`.
+- Windows. Windows has no POSIX signals.
+
+## The same concepts in other systems
+
+| Concept                                  | Other systems                                                                                                                                                                                                                                                          |
+| ---------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Termination signals that cancel the work | `signal.NotifyContext` of [Go](https://pkg.go.dev/os/signal#NotifyContext); `CancellationToken` and `ctrl_c` of [tokio](https://tokio.rs/tokio/topics/shutdown); `ApplicationStopping` of the .NET Generic Host                                                        |
+| Death by the signal after the cleanup    | [Proper handling of SIGINT/SIGQUIT](https://www.cons.org/cracauer/sigint.html) (Cracauer); [Termination in Handler](https://sourceware.org/glibc/manual/latest/html_node/Termination-in-Handler.html) of the GNU C Library; `signal-exit`; `exitAsInterrupted()` of Nx |
+| The default action for a second signal   | `stop()` of Go's `NotifyContext`; the SIGINT watcher of Playwright                                                                                                                                                                                                     |
+| A crash that starts a graceful shutdown  | `close-with-grace`, which the `eject` server templates of fastify-cli use                                                                                                                                                                                              |
+| An init process in a container           | `docker run --init` and tini                                                                                                                                                                                                                                           |
+
+## API
+
+```ts
+export class Shutdown implements Disposable {
+  /** Listens for SIGINT, SIGTERM, SIGHUP, uncaught exceptions and unhandled rejections. */
+  constructor();
+
+  /** Aborts at the first stop request. Its reason is the cause. */
+  readonly signal: AbortSignal;
+
+  /** Removes the listeners and aborts the signal. A stop request that came before stays. */
+  [Symbol.dispose](): void;
+}
+```
+
+| Call or event                       | What the package does                                                                                                                                                                                     |
+| ----------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `new Shutdown()`                    | `process.on()` for SIGINT, SIGTERM, SIGHUP, `'uncaughtException'`, `'unhandledRejection'` and `'exit'`                                                                                                    |
+| The first termination signal        | `process.off()` for each termination signal listener of the package, then `AbortController.abort()` with the `AbortError`                                                                                 |
+| The first crash                     | `console.error()` of the error, `process.off()` for each termination signal and crash listener of the package, then `abort()` with the error                                                              |
+| A crash after a termination signal  | `console.error()` of the error, then `process.exit()`. The `'exit'` listener then ends the process by the signal                                                                                          |
+| `'exit'` after a termination signal | `process.removeAllListeners()` for that termination signal, then `process.kill(process.pid, signal)`. When the process still runs: `process.exitCode = 128 + n` (`util.convertProcessSignalToExitCode()`) |
+| `'exit'` after a crash              | `process.exitCode \|\|= 1`: exit code 1, unless the program set a failure code                                                                                                                            |
+| `[Symbol.dispose]()`                | With no stop request: `process.off()` for each listener of the package, `'exit'` too, then `abort()`. After a stop request: nothing                                                                       |
+
+## Who uses each part
+
+The consumers below come from the search of 2026-11-02. None of them dies by the termination signal today. The package itself is backlog mutex #3579.
+
+| Consumer                                                                 | Uses                          | Backlog                |
+| ------------------------------------------------------------------------ | ----------------------------- | ---------------------- |
+| context-compiler: logful, startup-credits and its eval, what-is-going-on | `signal`, the exit status     | context-compiler #3580 |
+| context-compiler: the MCP server of the Codex plugin                     | `signal`, to close the server | context-compiler #3580 |
+| elt: the proactive app                                                   | `signal`, the exit status     | elt #3581              |

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { Shutdown } from './shutdown.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC"}

package/dist/index.js

@@ -0,0 +1,2 @@
+export { Shutdown } from "./shutdown.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC"}

package/dist/shutdown.d.ts

@@ -0,0 +1,7 @@
+export declare class Shutdown implements Disposable {
+    #private;
+    constructor();
+    get signal(): AbortSignal;
+    [Symbol.dispose](): void;
+}
+//# sourceMappingURL=shutdown.d.ts.map

package/dist/shutdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shutdown.d.ts","sourceRoot":"","sources":["../src/shutdown.ts"],"names":[],"mappings":"AAgBA,qBAAa,QAAS,YAAW,UAAU;;;IAoDzC,IAAI,MAAM,IAAI,WAAW,CAExB;IAgBD,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI;CAWzB"}

package/dist/shutdown.js

@@ -0,0 +1,82 @@
+import { convertProcessSignalToExitCode } from 'node:util';
+const terminationSignals = ['SIGINT', 'SIGTERM', 'SIGHUP'];
+/** The reason of the signal when a termination signal is the cause. */
+class TerminationSignalReceived extends DOMException {
+    terminationSignal;
+    constructor(terminationSignal) {
+        super(`The process received ${terminationSignal}`, 'AbortError');
+        this.terminationSignal = terminationSignal;
+    }
+}
+export class Shutdown {
+    #controller = new AbortController();
+    // A second termination signal gets the default action (ADR 0002). The
+    // crash listeners stay: see #onCrash.
+    #onTerminationSignal = (signal) => {
+        this.#stopListeningForSignals();
+        this.#controller.abort(new TerminationSignalReceived(signal));
+    };
+    // With a listener, Node.js does not write the error, so the package does
+    // (ADR 0003). A crash after a termination signal ends the process at once:
+    // process.exit() emits 'exit', and there the process dies by the signal.
+    // The default of Node.js would lose the error: with no listener, it emits
+    // 'exit' before it writes the error (lib/internal/process/execution.js).
+    #onCrash = (error) => {
+        console.error(error);
+        if (this.#controller.signal.reason instanceof TerminationSignalReceived) {
+            process.exit();
+        }
+        this.#stopListeningForSignals();
+        this.#stopListeningForCrashes();
+        this.#controller.abort(error);
+    };
+    // After the cleanup, the process dies by the termination signal that caused
+    // the shutdown (ADR 0001). The other listeners for that signal go first, or
+    // one of them would take it. The kernel does not apply the default action
+    // to PID 1, so there the process lives on, and it exits with the code that a
+    // shell shows for the signal. After a crash, the exit code is 1 (ADR 0003).
+    #onExit = () => {
+        const cause = this.#controller.signal.reason;
+        if (cause instanceof TerminationSignalReceived) {
+            process.removeAllListeners(cause.terminationSignal);
+            process.kill(process.pid, cause.terminationSignal);
+            process.exitCode = convertProcessSignalToExitCode(cause.terminationSignal);
+        }
+        else if (this.#controller.signal.aborted) {
+            process.exitCode ||= 1;
+        }
+    };
+    constructor() {
+        for (const signal of terminationSignals) {
+            process.on(signal, this.#onTerminationSignal);
+        }
+        process.on('uncaughtException', this.#onCrash);
+        process.on('unhandledRejection', this.#onCrash);
+        process.on('exit', this.#onExit);
+    }
+    get signal() {
+        return this.#controller.signal;
+    }
+    #stopListeningForSignals() {
+        for (const signal of terminationSignals) {
+            process.off(signal, this.#onTerminationSignal);
+        }
+    }
+    #stopListeningForCrashes() {
+        process.off('uncaughtException', this.#onCrash);
+        process.off('unhandledRejection', this.#onCrash);
+    }
+    // A stop request that came before the end of the scope stays. Each listener
+    // left after it ends the process by its cause, so the end of the scope
+    // removes none of them.
+    [Symbol.dispose]() {
+        if (this.#controller.signal.aborted) {
+            return;
+        }
+        this.#stopListeningForSignals();
+        this.#stopListeningForCrashes();
+        process.off('exit', this.#onExit);
+        this.#controller.abort(new DOMException('The shutdown scope ended', 'AbortError'));
+    }
+}
+//# sourceMappingURL=shutdown.js.map

package/dist/shutdown.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shutdown.js","sourceRoot":"","sources":["../src/shutdown.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,47 @@
 {
   "name": "@zukhruf/shutdown",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.6.13",
+  "description": "A graceful shutdown for a Node.js program: SIGINT, SIGTERM, SIGHUP and crashes abort one AbortSignal, the program runs its cleanup, and then the process dies by the termination signal, so a shell, Docker or Kubernetes sees an interrupted process.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/JanuaryLabs/zukhruf",
+    "directory": "packages/shutdown"
+  },
+  "bugs": {
+    "url": "https://github.com/JanuaryLabs/zukhruf/issues"
+  },
+  "homepage": "https://github.com/JanuaryLabs/zukhruf/tree/main/packages/shutdown#readme",
+  "keywords": [
+    "shutdown",
+    "graceful-shutdown",
+    "signal",
+    "sigint",
+    "sigterm",
+    "sighup",
+    "abortsignal",
+    "exit"
+  ],
+  "type": "module",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "@zukhruf/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!dist/spec/**",
+    "!**/*.tsbuildinfo",
+    "!**/*.test.*"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@zukhruf/docker": "^0.6.13"
+  }
+}