omegon 0.6.8 → 0.6.9

package/extensions/cleave/dispatcher.ts

@@ -27,6 +27,7 @@ import { executeWithReview, type ReviewConfig, type ReviewExecutor, DEFAULT_REVI
 import { saveState } from "./workspace.ts";
 import { resolveTier, getDefaultPolicy, getViableModels, type ProviderRoutingPolicy, type RegistryModel } from "../lib/model-routing.ts";
 import { resolveOmegonSubprocess } from "../lib/omegon-subprocess.ts";
+import { registerCleaveProc, deregisterCleaveProc, killCleaveProc } from "./subprocess-tracker.ts";
 
 // ─── Large-run threshold ────────────────────────────────────────────────────
 
@@ -385,6 +386,7 @@ async function spawnChild(
 		const proc = spawn(omegon.command, args, {
 			cwd,
 			stdio: ["pipe", "pipe", "pipe"],
+			detached: true,
 			env: {
 				...process.env,
 				// Prevent nested detection issues
@@ -393,6 +395,7 @@ async function spawnChild(
 				I_AM: "alpharius",
 			},
 		});
+		registerCleaveProc(proc);
 
 		// Write prompt to stdin
 		if (proc.stdin) {
@@ -417,24 +420,43 @@ async function spawnChild(
 		});
 		proc.stderr?.on("data", (data) => { stderr += data.toString(); });
 
+		// SIGKILL escalation helper — sends SIGKILL by process group with fallback
+		let escalationTimer: ReturnType<typeof setTimeout> | undefined;
+		const scheduleEscalation = () => {
+			escalationTimer = setTimeout(() => {
+				if (!proc.killed) {
+					try {
+						if (proc.pid) process.kill(-proc.pid, "SIGKILL");
+					} catch {
+						try { proc.kill("SIGKILL"); } catch { /* already dead */ }
+					}
+				}
+			}, 5_000);
+		};
+
 		// Timeout enforcement
 		const timer = setTimeout(() => {
 			killed = true;
-			proc.kill("SIGTERM");
-			setTimeout(() => {
-				if (!proc.killed) proc.kill("SIGKILL");
-			}, 5_000);
+			killCleaveProc(proc);
+			scheduleEscalation();
 		}, timeoutMs);
 
-		// Abort signal support
+		// Abort signal support (with SIGKILL escalation — detached processes
+		// won't receive SIGHUP on parent exit, so SIGTERM alone is insufficient)
 		const onAbort = () => {
 			killed = true;
-			proc.kill("SIGTERM");
+			killCleaveProc(proc);
+			scheduleEscalation();
 		};
 		signal?.addEventListener("abort", onAbort, { once: true });
 
+		let settled = false;
 		proc.on("close", (code) => {
+			if (settled) return;
+			settled = true;
+			deregisterCleaveProc(proc);
 			clearTimeout(timer);
+			clearTimeout(escalationTimer);
 			signal?.removeEventListener("abort", onAbort);
 			resolve({
 				exitCode: killed ? -1 : (code ?? 1),
@@ -444,7 +466,11 @@ async function spawnChild(
 		});
 
 		proc.on("error", (err) => {
+			if (settled) return;
+			settled = true;
+			deregisterCleaveProc(proc);
 			clearTimeout(timer);
+			clearTimeout(escalationTimer);
 			signal?.removeEventListener("abort", onAbort);
 			resolve({
 				exitCode: 1,

package/extensions/cleave/index.ts

@@ -20,6 +20,7 @@ import { truncateTail, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize } from "
 import { Text } from "@styrene-lab/pi-tui";
 import { Type } from "@sinclair/typebox";
 import { spawn, execFile } from "node:child_process";
+import { registerCleaveProc, deregisterCleaveProc, killCleaveProc, killAllCleaveSubprocesses } from "./subprocess-tracker.ts";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { promisify } from "node:util";
@@ -766,12 +767,14 @@ async function runSpecAssessmentSubprocess(
 			cwd: input.repoPath,
 			shell: false,
 			stdio: ["pipe", "pipe", "pipe"],
+			detached: true,
 			env: {
 				...process.env,
 				PI_CHILD: "1",
 				TERM: process.env.TERM ?? "dumb",
 			},
 		});
+		registerCleaveProc(proc);
 		let stdout = "";
 		let stderr = "";
 		let buffer = "";
@@ -789,10 +792,17 @@ async function runSpecAssessmentSubprocess(
 			clearTimeout(timer);
 			resolve(value);
 		};
+		let escalationTimer: ReturnType<typeof setTimeout> | undefined;
 		const timer = setTimeout(() => {
-			proc.kill("SIGTERM");
-			setTimeout(() => {
-				if (!proc.killed) proc.kill("SIGKILL");
+			killCleaveProc(proc);
+			escalationTimer = setTimeout(() => {
+				if (!proc.killed) {
+					try {
+						if (proc.pid) process.kill(-proc.pid, "SIGKILL");
+					} catch {
+						try { proc.kill("SIGKILL"); } catch { /* already dead */ }
+					}
+				}
 			}, 5_000);
 			settleReject(new Error(`Timed out after 120s while assessing ${input.changeName}.`));
 		}, 120_000);
@@ -823,9 +833,13 @@ async function runSpecAssessmentSubprocess(
 			stderr += data.toString();
 		});
 		proc.on("error", (error) => {
+			deregisterCleaveProc(proc);
+			clearTimeout(escalationTimer);
 			settleReject(error);
 		});
 		proc.on("close", (code) => {
+			deregisterCleaveProc(proc);
+			clearTimeout(escalationTimer);
 			if (buffer.trim()) processLine(buffer.trim());
 			if ((code ?? 1) !== 0) {
 				settleReject(new Error(stderr.trim() || `Assessment subprocess exited with code ${code ?? 1}.`));
@@ -1688,6 +1702,10 @@ export default function cleaveExtension(pi: ExtensionAPI) {
 		}
 	});
 
+	// ── Subprocess cleanup on session exit ───────────────────────────────
+	pi.on("session_shutdown", () => {
+		killAllCleaveSubprocesses();
+	});
 
 	// ── cleave_assess tool ───────────────────────────────────────────────
 	pi.registerTool({

package/extensions/cleave/subprocess-tracker.ts

@@ -0,0 +1,72 @@
+/**
+ * cleave/subprocess-tracker — Process registry for cleave subprocesses.
+ *
+ * Mirrors the extraction-v2 pattern: all spawned child processes are tracked
+ * in a Set, killed by process group (SIGTERM to -pid), and cleaned up on
+ * session_shutdown. Prevents orphaned `pi` processes when assessments time
+ * out or sessions exit mid-dispatch.
+ */
+
+import type { ChildProcess } from "node:child_process";
+
+const allCleaveProcs = new Set<ChildProcess>();
+
+/** Kill a single subprocess by process group, with fallback to direct kill. */
+export function killCleaveProc(proc: ChildProcess): void {
+	try {
+		if (proc.pid) process.kill(-proc.pid, "SIGTERM");
+	} catch {
+		try { proc.kill("SIGTERM"); } catch { /* already dead */ }
+	}
+}
+
+/** Add a subprocess to the tracked set. */
+export function registerCleaveProc(proc: ChildProcess): void {
+	allCleaveProcs.add(proc);
+}
+
+/** Remove a subprocess from the tracked set. */
+export function deregisterCleaveProc(proc: ChildProcess): void {
+	allCleaveProcs.delete(proc);
+}
+
+/**
+ * Force-kill a single subprocess (SIGKILL) by process group, with fallback.
+ * Used for escalation when SIGTERM is ignored.
+ */
+function forceKillCleaveProc(proc: ChildProcess): void {
+	try {
+		if (proc.pid) process.kill(-proc.pid, "SIGKILL");
+	} catch {
+		try { proc.kill("SIGKILL"); } catch { /* already dead */ }
+	}
+}
+
+/**
+ * Kill all tracked cleave subprocesses and clear the registry.
+ * Sends SIGTERM immediately, then SIGKILL after 5 seconds to any survivors.
+ * Because cleave subprocesses are spawned with `detached: true`, they will
+ * NOT receive SIGHUP when the parent exits — SIGKILL escalation is required.
+ */
+export function killAllCleaveSubprocesses(): void {
+	const snapshot = [...allCleaveProcs];
+	for (const proc of snapshot) {
+		killCleaveProc(proc);
+	}
+	// Escalate: SIGKILL after 5s for any process that ignored SIGTERM.
+	// The timer is unref'd so it does not keep the Node.js event loop alive.
+	if (snapshot.length > 0) {
+		const escalation = setTimeout(() => {
+			for (const proc of snapshot) {
+				if (!proc.killed) forceKillCleaveProc(proc);
+			}
+		}, 5_000);
+		escalation.unref();
+	}
+	allCleaveProcs.clear();
+}
+
+/** Number of currently tracked subprocesses (for diagnostics). */
+export function cleaveTrackedProcCount(): number {
+	return allCleaveProcs.size;
+}

package/node_modules/@mariozechner/clipboard-linux-x64-gnu/README.md

@@ -0,0 +1,3 @@
+# `@mariozechner/clipboard-linux-x64-gnu`
+
+This is the **x86_64-unknown-linux-gnu** binary for `@mariozechner/clipboard`

package/node_modules/@mariozechner/{clipboard-darwin-arm64 → clipboard-linux-x64-gnu}/package.json

@@ -1,20 +1,23 @@
 {
-  "name": "@mariozechner/clipboard-darwin-arm64",
+  "name": "@mariozechner/clipboard-linux-x64-gnu",
   "version": "0.3.2",
   "os": [
-    "darwin"
+    "linux"
   ],
   "cpu": [
-    "arm64"
+    "x64"
   ],
-  "main": "clipboard.darwin-arm64.node",
+  "main": "clipboard.linux-x64-gnu.node",
   "files": [
-    "clipboard.darwin-arm64.node"
+    "clipboard.linux-x64-gnu.node"
   ],
   "license": "MIT",
   "engines": {
     "node": ">= 10"
   },
+  "libc": [
+    "glibc"
+  ],
   "repository": {
     "type": "git",
     "url": "https://github.com/badlogic/clipboard.git"

package/node_modules/@types/node/README.md

@@ -5,10 +5,10 @@
 This package contains type definitions for node (https://nodejs.org/).
 
 # Details
-Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node/v24.
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node.
 
 ### Additional Details
- * Last updated: Fri, 06 Mar 2026 05:19:15 GMT
+ * Last updated: Thu, 12 Mar 2026 15:47:58 GMT
  * Dependencies: [undici-types](https://npmjs.com/package/undici-types)
 
 # Credits

package/node_modules/@types/node/assert/strict.d.ts

@@ -40,11 +40,11 @@
  * To deactivate the colors, use the `NO_COLOR` or `NODE_DISABLE_COLORS`
  * environment variables. This will also deactivate the colors in the REPL. For
  * more on color support in terminal environments, read the tty
- * [`getColorDepth()`](https://nodejs.org/docs/latest-v24.x/api/tty.html#writestreamgetcolordepthenv) documentation.
+ * [`getColorDepth()`](https://nodejs.org/docs/latest-v25.x/api/tty.html#writestreamgetcolordepthenv) documentation.
  * @since v15.0.0
- * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/assert/strict.js)
+ * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/assert/strict.js)
  */
-declare module "assert/strict" {
+declare module "node:assert/strict" {
     import {
         Assert,
         AssertionError,
@@ -52,9 +52,6 @@ declare module "assert/strict" {
         AssertOptions,
         AssertPredicate,
         AssertStrict,
-        CallTracker,
-        CallTrackerCall,
-        CallTrackerReportInformation,
         deepStrictEqual,
         doesNotMatch,
         doesNotReject,
@@ -79,9 +76,6 @@ declare module "assert/strict" {
             AssertOptions,
             AssertPredicate,
             AssertStrict,
-            CallTracker,
-            CallTrackerCall,
-            CallTrackerReportInformation,
             deepStrictEqual,
             deepStrictEqual as deepEqual,
             doesNotMatch,
@@ -105,7 +99,7 @@ declare module "assert/strict" {
     }
     export = strict;
 }
-declare module "node:assert/strict" {
-    import strict = require("assert/strict");
+declare module "assert/strict" {
+    import strict = require("node:assert/strict");
     export = strict;
 }

package/node_modules/@types/node/assert.d.ts

@@ -1,10 +1,10 @@
 /**
  * The `node:assert` module provides a set of assertion functions for verifying
  * invariants.
- * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/assert.js)
+ * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/assert.js)
  */
-declare module "assert" {
-    import strict = require("assert/strict");
+declare module "node:assert" {
+    import strict = require("node:assert/strict");
     /**
      * An alias of {@link assert.ok}.
      * @since v0.5.9
@@ -182,154 +182,6 @@ declare module "assert" {
              */
             operator: string;
         }
-        /**
-         * This feature is deprecated and will be removed in a future version.
-         * Please consider using alternatives such as the `mock` helper function.
-         * @since v14.2.0, v12.19.0
-         * @deprecated Deprecated
-         */
-        class CallTracker {
-            /**
-             * The wrapper function is expected to be called exactly `exact` times. If the
-             * function has not been called exactly `exact` times when `tracker.verify()` is called, then `tracker.verify()` will throw an
-             * error.
-             *
-             * ```js
-             * import assert from 'node:assert';
-             *
-             * // Creates call tracker.
-             * const tracker = new assert.CallTracker();
-             *
-             * function func() {}
-             *
-             * // Returns a function that wraps func() that must be called exact times
-             * // before tracker.verify().
-             * const callsfunc = tracker.calls(func);
-             * ```
-             * @since v14.2.0, v12.19.0
-             * @param [fn='A no-op function']
-             * @param [exact=1]
-             * @return A function that wraps `fn`.
-             */
-            calls(exact?: number): () => void;
-            calls(fn: undefined, exact?: number): () => void;
-            calls<Func extends (...args: any[]) => any>(fn: Func, exact?: number): Func;
-            calls<Func extends (...args: any[]) => any>(fn?: Func, exact?: number): Func | (() => void);
-            /**
-             * Example:
-             *
-             * ```js
-             * import assert from 'node:assert';
-             *
-             * const tracker = new assert.CallTracker();
-             *
-             * function func() {}
-             * const callsfunc = tracker.calls(func);
-             * callsfunc(1, 2, 3);
-             *
-             * assert.deepStrictEqual(tracker.getCalls(callsfunc),
-             *                        [{ thisArg: undefined, arguments: [1, 2, 3] }]);
-             * ```
-             * @since v18.8.0, v16.18.0
-             * @return An array with all the calls to a tracked function.
-             */
-            getCalls(fn: Function): CallTrackerCall[];
-            /**
-             * The arrays contains information about the expected and actual number of calls of
-             * the functions that have not been called the expected number of times.
-             *
-             * ```js
-             * import assert from 'node:assert';
-             *
-             * // Creates call tracker.
-             * const tracker = new assert.CallTracker();
-             *
-             * function func() {}
-             *
-             * // Returns a function that wraps func() that must be called exact times
-             * // before tracker.verify().
-             * const callsfunc = tracker.calls(func, 2);
-             *
-             * // Returns an array containing information on callsfunc()
-             * console.log(tracker.report());
-             * // [
-             * //  {
-             * //    message: 'Expected the func function to be executed 2 time(s) but was
-             * //    executed 0 time(s).',
-             * //    actual: 0,
-             * //    expected: 2,
-             * //    operator: 'func',
-             * //    stack: stack trace
-             * //  }
-             * // ]
-             * ```
-             * @since v14.2.0, v12.19.0
-             * @return An array of objects containing information about the wrapper functions returned by {@link tracker.calls()}.
-             */
-            report(): CallTrackerReportInformation[];
-            /**
-             * Reset calls of the call tracker. If a tracked function is passed as an argument, the calls will be reset for it.
-             * If no arguments are passed, all tracked functions will be reset.
-             *
-             * ```js
-             * import assert from 'node:assert';
-             *
-             * const tracker = new assert.CallTracker();
-             *
-             * function func() {}
-             * const callsfunc = tracker.calls(func);
-             *
-             * callsfunc();
-             * // Tracker was called once
-             * assert.strictEqual(tracker.getCalls(callsfunc).length, 1);
-             *
-             * tracker.reset(callsfunc);
-             * assert.strictEqual(tracker.getCalls(callsfunc).length, 0);
-             * ```
-             * @since v18.8.0, v16.18.0
-             * @param fn a tracked function to reset.
-             */
-            reset(fn?: Function): void;
-            /**
-             * Iterates through the list of functions passed to {@link tracker.calls()} and will throw an error for functions that
-             * have not been called the expected number of times.
-             *
-             * ```js
-             * import assert from 'node:assert';
-             *
-             * // Creates call tracker.
-             * const tracker = new assert.CallTracker();
-             *
-             * function func() {}
-             *
-             * // Returns a function that wraps func() that must be called exact times
-             * // before tracker.verify().
-             * const callsfunc = tracker.calls(func, 2);
-             *
-             * callsfunc();
-             *
-             * // Will throw an error since callsfunc() was only called once.
-             * tracker.verify();
-             * ```
-             * @since v14.2.0, v12.19.0
-             */
-            verify(): void;
-        }
-        interface CallTrackerCall {
-            thisArg: object;
-            arguments: unknown[];
-        }
-        interface CallTrackerReportInformation {
-            message: string;
-            /** The actual number of times the function was called. */
-            actual: number;
-            /** The number of times the function was expected to be called. */
-            expected: number;
-            /** The name of the function that is wrapped. */
-            operator: string;
-            /** A stack trace of the function. */
-            stack: object;
-        }
         type AssertPredicate = RegExp | (new() => object) | ((thrown: unknown) => boolean) | object | Error;
         /**
          * Throws an `AssertionError` with the provided error message or a default
@@ -348,22 +200,10 @@ declare module "assert" {
          * assert.fail(new TypeError('need array'));
          * // TypeError: need array
          * ```
-         *
-         * Using `assert.fail()` with more than two arguments is possible but deprecated.
-         * See below for further details.
          * @since v0.1.21
          * @param [message='Failed']
          */
         function fail(message?: string | Error): never;
-        /** @deprecated since v10.0.0 - use fail([message]) or other assert functions instead. */
-        function fail(
-            actual: unknown,
-            expected: unknown,
-            message?: string | Error,
-            operator?: string,
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
-            stackStartFn?: Function,
-        ): never;
         /**
          * Tests if `value` is truthy. It is equivalent to `assert.equal(!!value, true, message)`.
          *
@@ -413,10 +253,10 @@ declare module "assert" {
          * import assert from 'node:assert/strict';
          *
          * // Using `assert()` works the same:
-         * assert(0);
+         * assert(2 + 2 > 5);;
          * // AssertionError: The expression evaluated to a falsy value:
          * //
-         * //   assert(0)
+         * //   assert(2 + 2 > 5)
          * ```
          * @since v0.1.21
          */
@@ -931,7 +771,7 @@ declare module "assert" {
          * check that the promise is rejected.
          *
          * If `asyncFn` is a function and it throws an error synchronously, `assert.rejects()` will return a rejected `Promise` with that error. If the
-         * function does not return a promise, `assert.rejects()` will return a rejected `Promise` with an [ERR_INVALID_RETURN_VALUE](https://nodejs.org/docs/latest-v24.x/api/errors.html#err_invalid_return_value)
+         * function does not return a promise, `assert.rejects()` will return a rejected `Promise` with an [ERR_INVALID_RETURN_VALUE](https://nodejs.org/docs/latest-v25.x/api/errors.html#err_invalid_return_value)
          * error. In both cases the error handler is skipped.
          *
          * Besides the async nature to await the completion behaves identically to {@link throws}.
@@ -1001,7 +841,7 @@ declare module "assert" {
          *
          * If `asyncFn` is a function and it throws an error synchronously, `assert.doesNotReject()` will return a rejected `Promise` with that error. If
          * the function does not return a promise, `assert.doesNotReject()` will return a
-         * rejected `Promise` with an [ERR_INVALID_RETURN_VALUE](https://nodejs.org/docs/latest-v24.x/api/errors.html#err_invalid_return_value) error. In both cases
+         * rejected `Promise` with an [ERR_INVALID_RETURN_VALUE](https://nodejs.org/docs/latest-v25.x/api/errors.html#err_invalid_return_value) error. In both cases
          * the error handler is skipped.
          *
          * Using `assert.doesNotReject()` is actually not useful because there is little
@@ -1064,7 +904,7 @@ declare module "assert" {
          * If the values do not match, or if the `string` argument is of another type than `string`, an `{@link AssertionError}` is thrown with a `message` property set equal
          * to the value of the `message` parameter. If the `message` parameter is
          * undefined, a default error message is assigned. If the `message` parameter is an
-         * instance of an [Error](https://nodejs.org/docs/latest-v24.x/api/errors.html#class-error) then it will be thrown instead of the `{@link AssertionError}`.
+         * instance of an [Error](https://nodejs.org/docs/latest-v25.x/api/errors.html#class-error) then it will be thrown instead of the `{@link AssertionError}`.
          * @since v13.6.0, v12.16.0
          */
         function match(value: string, regExp: RegExp, message?: string | Error): void;
@@ -1087,7 +927,7 @@ declare module "assert" {
          * If the values do match, or if the `string` argument is of another type than `string`, an `{@link AssertionError}` is thrown with a `message` property set equal
          * to the value of the `message` parameter. If the `message` parameter is
          * undefined, a default error message is assigned. If the `message` parameter is an
-         * instance of an [Error](https://nodejs.org/docs/latest-v24.x/api/errors.html#class-error) then it will be thrown instead of the `{@link AssertionError}`.
+         * instance of an [Error](https://nodejs.org/docs/latest-v25.x/api/errors.html#class-error) then it will be thrown instead of the `{@link AssertionError}`.
          * @since v13.6.0, v12.16.0
          */
         function doesNotMatch(value: string, regExp: RegExp, message?: string | Error): void;
@@ -1109,7 +949,7 @@ declare module "assert" {
     }
     export = assert;
 }
-declare module "node:assert" {
-    import assert = require("assert");
+declare module "assert" {
+    import assert = require("node:assert");
     export = assert;
 }

package/node_modules/@types/node/async_hooks.d.ts

@@ -2,8 +2,8 @@
  * We strongly discourage the use of the `async_hooks` API.
  * Other APIs that can cover most of its use cases include:
  *
- * * [`AsyncLocalStorage`](https://nodejs.org/docs/latest-v24.x/api/async_context.html#class-asynclocalstorage) tracks async context
- * * [`process.getActiveResourcesInfo()`](https://nodejs.org/docs/latest-v24.x/api/process.html#processgetactiveresourcesinfo) tracks active resources
+ * * [`AsyncLocalStorage`](https://nodejs.org/docs/latest-v25.x/api/async_context.html#class-asynclocalstorage) tracks async context
+ * * [`process.getActiveResourcesInfo()`](https://nodejs.org/docs/latest-v25.x/api/process.html#processgetactiveresourcesinfo) tracks active resources
  *
  * The `node:async_hooks` module provides an API to track asynchronous resources.
  * It can be accessed using:
@@ -12,9 +12,9 @@
  * import async_hooks from 'node:async_hooks';
  * ```
  * @experimental
- * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/async_hooks.js)
+ * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/async_hooks.js)
  */
-declare module "async_hooks" {
+declare module "node:async_hooks" {
     /**
      * ```js
      * import { executionAsyncId } from 'node:async_hooks';
@@ -44,7 +44,7 @@ declare module "async_hooks" {
      * ```
      *
      * Promise contexts may not get precise `executionAsyncIds` by default.
-     * See the section on [promise execution tracking](https://nodejs.org/docs/latest-v24.x/api/async_hooks.html#promise-execution-tracking).
+     * See the section on [promise execution tracking](https://nodejs.org/docs/latest-v25.x/api/async_hooks.html#promise-execution-tracking).
      * @since v8.1.0
      * @return The `asyncId` of the current execution context. Useful to track when something calls.
      */
@@ -117,7 +117,7 @@ declare module "async_hooks" {
      * ```
      *
      * Promise contexts may not get valid `triggerAsyncId`s by default. See
-     * the section on [promise execution tracking](https://nodejs.org/docs/latest-v24.x/api/async_hooks.html#promise-execution-tracking).
+     * the section on [promise execution tracking](https://nodejs.org/docs/latest-v25.x/api/async_hooks.html#promise-execution-tracking).
      * @return The ID of the resource responsible for calling the callback that is currently being executed.
      */
     function triggerAsyncId(): number;
@@ -618,6 +618,6 @@ declare module "async_hooks" {
         const VERIFYREQUEST: number;
     }
 }
-declare module "node:async_hooks" {
-    export * from "async_hooks";
+declare module "async_hooks" {
+    export * from "node:async_hooks";
 }

package/node_modules/@types/node/buffer.buffer.d.ts

@@ -1,4 +1,4 @@
-declare module "buffer" {
+declare module "node:buffer" {
     type ImplicitArrayBuffer<T extends WithImplicitCoercion<ArrayBufferLike>> = T extends
         { valueOf(): infer V extends ArrayBufferLike } ? V : T;
     global {
@@ -463,10 +463,4 @@ declare module "buffer" {
          */
         type AllowSharedBuffer = Buffer<ArrayBufferLike>;
     }
-    /** @deprecated Use `Buffer.allocUnsafeSlow()` instead. */
-    var SlowBuffer: {
-        /** @deprecated Use `Buffer.allocUnsafeSlow()` instead. */
-        new(size: number): Buffer<ArrayBuffer>;
-        prototype: Buffer;
-    };
 }