@idlebox/node 1.4.11 → 1.4.13

package/src/autoindex.ts

@@ -3,151 +3,145 @@
 /* eslint-disable */
 
 /* asyncLoad.ts */
-// Identifiers
-export type { AsyncMainFunction } from './asyncLoad.js';
-export { executeMainFunction } from './asyncLoad.js';
+	// Identifiers
+	export type { AsyncMainFunction } from "./asyncLoad.js";
+	export { executeMainFunction } from "./asyncLoad.js";
 /* preload.ts */
-// Identifiers
+	// Identifiers
 /* child_process/error.ts */
-// Identifiers
-export { checkChildProcessResult } from './child_process/error.js';
+	// Identifiers
+	export { checkChildProcessResult } from "./child_process/error.js";
 /* child_process/execa.ts */
-// Identifiers
-export type { ICommand } from './child_process/execa.js';
-export { spawnWithoutOutputSync } from './child_process/execa.js';
-export { spawnWithoutOutput } from './child_process/execa.js';
-export { spawnGetOutputSync } from './child_process/execa.js';
-export { spawnGetOutput } from './child_process/execa.js';
-export { spawnGetEverything } from './child_process/execa.js';
+	// Identifiers
+	export type { ICommand } from "./child_process/execa.js";
+	export { spawnWithoutOutputSync } from "./child_process/execa.js";
+	export { spawnWithoutOutput } from "./child_process/execa.js";
+	export { spawnGetOutputSync } from "./child_process/execa.js";
+	export { spawnGetOutput } from "./child_process/execa.js";
+	export { spawnGetEverything } from "./child_process/execa.js";
 /* cli-io/output.ts */
-// Identifiers
-export { printLine } from './cli-io/output.js';
+	// Identifiers
+	export { printLine } from "./cli-io/output.js";
 /* child_process/lateError.ts */
-// Identifiers
-export type { ISpawnOptions } from './child_process/lateError.js';
-export type { ExecaReturnValue } from './child_process/lateError.js';
-export { execLazyError } from './child_process/lateError.js';
-/* error/linux.ts */
-// Identifiers
-export { LinuxError } from './error/linux.js';
-/* error/types.ts */
-// Identifiers
-export type { OpenSSLException } from './error/types.js';
-export { isModuleResolutionError } from './error/types.js';
-export { isNotExistsError } from './error/types.js';
-export { isExistsError } from './error/types.js';
-export { isTypeError } from './error/types.js';
-export { isFileTypeError } from './error/types.js';
-export { isNodeError } from './error/types.js';
-// References
-export * from '@idlebox/node-error-codes';
+	// Identifiers
+	export type { ISpawnOptions } from "./child_process/lateError.js";
+	export type { ExecaReturnValue } from "./child_process/lateError.js";
+	export { execLazyError } from "./child_process/lateError.js";
 /* fs/exists.ts */
-// Identifiers
-export { existsSync } from './fs/exists.js';
-export { exists } from './fs/exists.js';
-export { readFileIfExists } from './fs/exists.js';
+	// Identifiers
+	export { existsSync } from "./fs/exists.js";
+	export { exists } from "./fs/exists.js";
+	export { readFileIfExists } from "./fs/exists.js";
 /* environment/getEnvironment.ts */
-// Identifiers
-export type { IEnvironmentResult } from './environment/getEnvironment.js';
-export { getEnvironment } from './environment/getEnvironment.js';
-export { deleteEnvironment } from './environment/getEnvironment.js';
-export { cleanupEnvironment } from './environment/getEnvironment.js';
+	// Identifiers
+	export type { IEnvironmentResult } from "./environment/getEnvironment.js";
+	export { getEnvironment } from "./environment/getEnvironment.js";
+	export { deleteEnvironment } from "./environment/getEnvironment.js";
+	export { cleanupEnvironment } from "./environment/getEnvironment.js";
 /* environment/pathEnvironment.ts */
-// Identifiers
-export { PATH_SEPARATOR } from './environment/pathEnvironment.js';
-export { PathEnvironment } from './environment/pathEnvironment.js';
+	// Identifiers
+	export { PATH_SEPARATOR } from "./environment/pathEnvironment.js";
+	export { PathEnvironment } from "./environment/pathEnvironment.js";
 /* environment/findBinary.ts */
-// Identifiers
-export { findBinary } from './environment/findBinary.js';
+	// Identifiers
+	export { findBinary } from "./environment/findBinary.js";
 /* child_process/respawn.ts */
-// Identifiers
-export { spawnRecreateEventHandlers } from './child_process/respawn.js';
-export { trySpawnInScope } from './child_process/respawn.js';
-export { respawnInScope } from './child_process/respawn.js';
+	// Identifiers
+	export { spawnRecreateEventHandlers } from "./child_process/respawn.js";
+	export { trySpawnInScope } from "./child_process/respawn.js";
+	export { respawnInScope } from "./child_process/respawn.js";
 /* crypto/md5.ts */
-// Identifiers
-export { md5 } from './crypto/md5.js';
+	// Identifiers
+	export { md5 } from "./crypto/md5.js";
 /* crypto/sha256.ts */
-// Identifiers
-export { sha256 } from './crypto/sha256.js';
+	// Identifiers
+	export { sha256 } from "./crypto/sha256.js";
 /* environment/npmConfig.ts */
-// Identifiers
-export { getNpmConfigValue } from './environment/npmConfig.js';
+	// Identifiers
+	export { getNpmConfigValue } from "./environment/npmConfig.js";
 /* events/dumpEventEmitter.ts */
-// Identifiers
-export { dumpEventEmitterEmit } from './events/dumpEventEmitter.js';
+	// Identifiers
+	export { dumpEventEmitterEmit } from "./events/dumpEventEmitter.js";
 /* fs/commandExists.ts */
-// Identifiers
-export { commandInPath } from './fs/commandExists.js';
-export { commandInPathSync } from './fs/commandExists.js';
+	// Identifiers
+	export { commandInPath } from "./fs/commandExists.js";
+	export { commandInPathSync } from "./fs/commandExists.js";
 /* fs/emptyDir.ts */
-// Identifiers
-export { emptyDir } from './fs/emptyDir.js';
+	// Identifiers
+	export { emptyDir } from "./fs/emptyDir.js";
 /* fs/ensureDir.ts */
-// Identifiers
-export { ensureDirExists } from './fs/ensureDir.js';
-export { ensureParentExists } from './fs/ensureDir.js';
+	// Identifiers
+	export { ensureDirExists } from "./fs/ensureDir.js";
+	export { ensureParentExists } from "./fs/ensureDir.js";
 /* fs/tempFolder.ts */
-// Identifiers
-export { createTempFolder } from './fs/tempFolder.js';
+	// Identifiers
+	export { createTempFolder } from "./fs/tempFolder.js";
 /* fs/weiteChanged.ts */
-// Identifiers
-export { writeFileIfChangeSync } from './fs/weiteChanged.js';
-export { writeFileIfChange } from './fs/weiteChanged.js';
+	// Identifiers
+	export { writeFileIfChangeSync } from "./fs/weiteChanged.js";
+	export { writeFileIfChange } from "./fs/weiteChanged.js";
 /* lifecycle/register.ts */
-// Identifiers
-export { shutdown } from './lifecycle/register.js';
-export { registerNodejsExitHandler } from './lifecycle/register.js';
-export { die } from './lifecycle/register.js';
+	// Identifiers
+	export { setExitCodeIfNot } from "./lifecycle/register.js";
+	export { shutdown } from "./lifecycle/register.js";
+	export { registerNodejsGlobalTypedErrorHandlerWithInheritance } from "./lifecycle/register.js";
+	export { registerNodejsGlobalTypedErrorHandler } from "./lifecycle/register.js";
+	export { registerNodejsExitHandler } from "./lifecycle/register.js";
+	export { die } from "./lifecycle/register.js";
+/* lifecycle/workingDirectory.ts */
+	// Identifiers
+	export { workingDirectory } from "./lifecycle/workingDirectory.js";
 /* log/terminal.ts */
-// Identifiers
-export { WrappedTerminalConsole } from './log/terminal.js';
+	// Identifiers
+	export { WrappedTerminalConsole } from "./log/terminal.js";
 /* path-resolve/findUp.ts */
-// Identifiers
-export type { IFindOptions } from './path-resolve/findUp.js';
-export { findUpUntil } from './path-resolve/findUp.js';
-export { findUpUntilSync } from './path-resolve/findUp.js';
+	// Identifiers
+	export type { IFindOptions } from "./path-resolve/findUp.js";
+	export { findUpUntil } from "./path-resolve/findUp.js";
+	export { findUp } from "./path-resolve/findUp.js";
+	export { findUpUntilSync } from "./path-resolve/findUp.js";
+	export { findUpSync } from "./path-resolve/findUp.js";
 /* path-resolve/findPackageRoot.ts */
-// Identifiers
-export { findPackageRoot } from './path-resolve/findPackageRoot.js';
+	// Identifiers
+	export { findPackageRoot } from "./path-resolve/findPackageRoot.js";
 /* path-resolve/getAllUp.ts */
-// Identifiers
-export { getAllPathUpToRoot } from './path-resolve/getAllUp.js';
+	// Identifiers
+	export { getAllPathUpToRoot } from "./path-resolve/getAllUp.js";
 /* path-resolve/lrelative.ts */
-// Identifiers
-export { lrelative } from './path-resolve/lrelative.js';
+	// Identifiers
+	export { lrelative } from "./path-resolve/lrelative.js";
 /* path-resolve/nodeResolvePathArray.ts */
-// Identifiers
-export { nodeResolvePathArray } from './path-resolve/nodeResolvePathArray.js';
+	// Identifiers
+	export { nodeResolvePathArray } from "./path-resolve/nodeResolvePathArray.js";
 /* path-resolve/resolvePath.ts */
-// Identifiers
-export type { ResolvePathFunction } from './path-resolve/resolvePath.js';
-export type { JoinPathFunction } from './path-resolve/resolvePath.js';
-export { resolvePath } from './path-resolve/resolvePath.js';
-export type { NormalizePathFunction } from './path-resolve/resolvePath.js';
-export { normalizePath } from './path-resolve/resolvePath.js';
-export { osTempDir } from './path-resolve/resolvePath.js';
-export { relativePath } from './path-resolve/resolvePath.js';
+	// Identifiers
+	export type { ResolvePathFunction } from "./path-resolve/resolvePath.js";
+	export type { JoinPathFunction } from "./path-resolve/resolvePath.js";
+	export { resolvePath } from "./path-resolve/resolvePath.js";
+	export type { NormalizePathFunction } from "./path-resolve/resolvePath.js";
+	export { normalizePath } from "./path-resolve/resolvePath.js";
+	export { osTempDir } from "./path-resolve/resolvePath.js";
+	export { relativePath } from "./path-resolve/resolvePath.js";
 /* stream/blackHoleStream.ts */
-// Identifiers
-export { BlackHoleStream } from './stream/blackHoleStream.js';
+	// Identifiers
+	export { BlackHoleStream } from "./stream/blackHoleStream.js";
 /* stream/streamPromise.ts */
-// Identifiers
-export { streamPromise } from './stream/streamPromise.js';
-export { streamHasEnd } from './stream/streamPromise.js';
+	// Identifiers
+	export { streamPromise } from "./stream/streamPromise.js";
+	export { streamHasEnd } from "./stream/streamPromise.js";
 /* stream/collectingStream.ts */
-// Identifiers
-export { streamToBuffer } from './stream/collectingStream.js';
-export { RawCollectingStream } from './stream/collectingStream.js';
-export { CollectingStream } from './stream/collectingStream.js';
+	// Identifiers
+	export { streamToBuffer } from "./stream/collectingStream.js";
+	export { RawCollectingStream } from "./stream/collectingStream.js";
+	export { CollectingStream } from "./stream/collectingStream.js";
 /* stream/disposableStream.ts */
-// Identifiers
-export { disposableStream } from './stream/disposableStream.js';
+	// Identifiers
+	export { disposableStream } from "./stream/disposableStream.js";
 /* stream/drainStream.ts */
-// Identifiers
-export { drainStream } from './stream/drainStream.js';
+	// Identifiers
+	export { drainStream } from "./stream/drainStream.js";
 /* stream/loggerStream.ts */
-// Identifiers
-export type { LogFunction } from './stream/loggerStream.js';
-export { LoggerStream } from './stream/loggerStream.js';
-export { HexDumpLoggerStream } from './stream/loggerStream.js';
+	// Identifiers
+	export type { LogFunction } from "./stream/loggerStream.js";
+	export { LoggerStream } from "./stream/loggerStream.js";
+	export { HexDumpLoggerStream } from "./stream/loggerStream.js";

package/src/child_process/respawn.ts

@@ -9,6 +9,7 @@ if (platform() === 'linux' && process.getuid?.() !== 0) {
 	unshareArgs.push('--map-root-user');
 }
 
+/** @deprecated */
 export function spawnRecreateEventHandlers() {
 	process.on('SIGINT', () => shutdown_quit('SIGINT', 130));
 	process.on('SIGTERM', () => shutdown_quit('SIGTERM', 143));
@@ -26,6 +27,7 @@ function shutdown_quit(signal: string, code: number) {
 /**
  * Spawn a command, replace current node process
  * If can't do that (eg. on Windows), spawn as normal, but quit self after it quit.
+ * @deprecated
  */
 export function trySpawnInScope(cmds: string[]): never {
 	if (process.env.NEVER_UNSHARE || !process.execve || insideScope() || !supportScope()) {

package/src/fs/exists.ts

@@ -1,6 +1,6 @@
 import type { ObjectEncodingOptions } from 'node:fs';
 import { access, readFile } from 'node:fs/promises';
-import { isNotExistsError } from '../error/types.js';
+import { isNotExistsError } from '@idlebox/errors';
 export { existsSync } from 'node:fs';
 
 export async function exists(path: string) {

package/src/lifecycle/register.ts

@@ -1,13 +1,15 @@
 /** biome-ignore-all lint/suspicious/noDebugger: debug file */
 
-import { AppExit, ensureDisposeGlobal, ensureGlobalObject, prettyPrintError } from '@idlebox/common';
-import { createRequire, syncBuiltinESMExports } from 'node:module';
+import { ensureDisposeGlobal, ensureGlobalObject, functionName, isProductionMode, prettyPrintError, type MyCallback } from '@idlebox/common';
+import { ErrorWithCode, Exit, ExitCode, InterruptError, UncaughtException, UnhandledRejection } from '@idlebox/errors';
+import assert from 'node:assert';
+import { syncBuiltinESMExports } from 'node:module';
 import { basename } from 'node:path';
 import process from 'node:process';
+import { inspect } from 'node:util';
 
-const originalExit = process.exit;
+const originalExit: (code?: number) => never = process.exit;
 const prefix = process.stderr.isTTY ? '' : `<${title()} ${process.pid}> `;
-const hasInspect = process.argv.some((arg) => arg.startsWith('--inspect=') || arg.startsWith('--inspect-brk=') || arg === '--inspect' || arg === '--inspect-brk');
 
 function title() {
 	if (process.title && process.title !== 'node') {
@@ -16,87 +18,181 @@ function title() {
 	return basename(process.argv[1] || '') || 'node';
 }
 
-class Exit extends AppExit {
-	constructor(code: number) {
-		super(`process exit with code ${code}`, code);
+function getCurrentCode() {
+	return typeof process.exitCode === 'string' ? parseInt(process.exitCode) : process.exitCode || 0;
+}
+
+export function setExitCodeIfNot(exitCode: number) {
+	if (exitCode || typeof process.exitCode !== 'number') {
+		process.exitCode = exitCode;
+		globalThis.process.exitCode = exitCode;
 	}
 }
 
-const shuttingDown = false;
+let shuttingDown = 0;
 export function shutdown(exitCode: number): never {
-	if (hasInspect) debugger;
+	_shutdown(exitCode);
+	throw new Exit(getCurrentCode());
+}
+function _shutdown(exitCode: number) {
+	setExitCodeIfNot(exitCode);
+
+	if (!shuttingDown) {
+		shuttingDown = 1;
+		ensureDisposeGlobal().finally(() => {
+			originalExit(getCurrentCode());
+		});
+	} else {
+		shuttingDown++;
+	}
+}
 
-	if (exitCode) {
-		process.exitCode = exitCode;
+const typed_error_handlers = new WeakMap<ErrorConstructor, MyCallback<[Error]>>();
+const inherit_error_handlers = new Map<ErrorConstructor, MyCallback<[Error]>>();
+
+type ErrorConstructor = new (...args: any[]) => Error;
+
+export function registerNodejsGlobalTypedErrorHandlerWithInheritance(ErrorCls: ErrorConstructor, fn: MyCallback<[Error]>) {
+	if (typed_error_handlers.has(ErrorCls)) {
+		throw new ErrorCls(`conflict register of error type ${ErrorCls.name}`);
+	}
+	assert.notEqual(ErrorCls, Error, 'cannot register basic Error type');
+	inherit_error_handlers.set(ErrorCls, fn);
+}
+export function registerNodejsGlobalTypedErrorHandler(ErrorCls: ErrorConstructor, fn: MyCallback<[Error]>) {
+	if (typed_error_handlers.has(ErrorCls)) {
+		throw new ErrorCls(`conflict register of error type ${ErrorCls.name}`);
+	}
+	assert.notEqual(ErrorCls, Error, 'cannot register basic Error type');
+	typed_error_handlers.set(ErrorCls, fn);
+}
+
+function uniqueErrorHandler(e: unknown, logger: IDebugOutput) {
+	if (!isProductionMode) logger.verbose?.(`uniqueErrorHandler:`);
+	if (!(e instanceof Error)) {
+		prettyPrintError(`${prefix}catch unexpect object`, new Error(`error object is ${typeof e} ${e ? (e as any).constructor?.name : 'unknown'}`));
+		throw originalExit(ExitCode.PROGRAM);
 	}
-	const code = typeof process.exitCode === 'string' ? parseInt(process.exitCode) : process.exitCode || 0;
 
-	if (shuttingDown) {
-		throw new Exit(code);
+	if (e instanceof Exit) {
+		if (!isProductionMode) logger.verbose?.(`  - skip exit object`);
+		if (!shuttingDown) {
+			_shutdown(e.code);
+		}
+		throw e;
 	}
 
-	ensureDisposeGlobal().finally(() => {
-		originalExit(process.exitCode);
-	});
+	try {
+		const catcher = typed_error_handlers.get(e.constructor as ErrorConstructor);
+		if (catcher) {
+			if (!isProductionMode) logger.verbose?.(`  - call catcher ${functionName(catcher)}`);
+			catcher(e);
+			return;
+		}
+		for (const [Cls, fn] of inherit_error_handlers) {
+			if (!isProductionMode) logger.verbose?.(`  - call inherited catcher ${functionName(fn)}`);
+			if (e instanceof Cls) {
+				fn(e);
+				return;
+			}
+		}
+	} catch (ee: any) {
+		prettyPrintError(`${prefix}error while handle error`, {
+			message: ee.message,
+			stack: ee.stack,
+			cause: e,
+		});
+		return;
+	}
+
+	if (e instanceof InterruptError) {
+		if (!isProductionMode) logger.verbose?.(`  - shuttingDown = ${shuttingDown}`);
+		if (shuttingDown > 5) {
+			logger.output(`${prefix}Exiting immediately.`);
+			originalExit(ExitCode.INTERRUPT);
+		}
 
-	throw new Exit(code);
+		shutdown(ExitCode.INTERRUPT);
+	}
+	if (e instanceof UnhandledRejection) {
+		if (!isProductionMode) logger.verbose?.(`  - UnhandledRejection`);
+		if (e.cause instanceof Error) {
+			prettyPrintError(`${prefix}Unhandled Rejection`, e.cause);
+		} else {
+			logger.output(`${prefix}Unhandled Rejection / error type unknown: ${inspect(e.cause)}`);
+		}
+		return;
+	}
+	if (e instanceof UncaughtException) {
+		if (!isProductionMode) logger.verbose?.(`  - UncaughtException`);
+		prettyPrintError(`${prefix}Uncaught Exception`, e.cause);
+		return;
+	}
+
+	if (!isProductionMode) logger.verbose?.(`  - common error`);
+	prettyPrintError(`${prefix}unhandled global exception`, e);
+	shutdown(ExitCode.PROGRAM);
+}
+
+interface IDebugOutput {
+	output(message: string): void;
+	verbose?(message: string): void;
 }
 
 /**
  * 注册nodejs退出处理器
  */
-export function registerNodejsExitHandler() {
-	ensureGlobalObject('exithandler/register', _real_register);
+export function registerNodejsExitHandler(logger: IDebugOutput = { output: console.error }) {
+	ensureGlobalObject('exithandler/register', () => _real_register(logger));
 }
-function _real_register() {
+function _real_register(logger: IDebugOutput) {
+	logger.verbose?.(`register nodejs exit handler: production=${isProductionMode}`);
 	process.on('SIGINT', () => {
-		console.error(`\n${prefix}Received SIGINT. Exiting gracefully...`);
-
-		if (shuttingDown) {
-			console.error(`Exiting immediately.`);
-			originalExit(1);
-		}
-
-		shutdown(0);
+		logger.output(`\n${prefix}Received SIGINT. Exiting gracefully...`);
+		uniqueErrorHandler(new InterruptError('SIGINT'), logger);
 	});
 
 	process.on('SIGTERM', () => {
-		console.error(`${prefix}Received SIGTERM. Exiting gracefully...`);
-		shutdown(0);
+		logger.output(`${prefix}Received SIGTERM. Exiting gracefully...`);
+		uniqueErrorHandler(new InterruptError('SIGTERM'), logger);
 	});
 
 	process.on('beforeExit', (code) => {
-		console.error(`${prefix}Process beforeExit with code: ${code}`);
-		shutdown(code);
+		// empty handler prevent real exit
+		if (!isProductionMode) logger.verbose?.(`process: beforeExit: ${code}`);
+		if (process.exitCode === undefined || process.exitCode === '') {
+			code = ExitCode.EXECUTION;
+			logger.output(`${prefix}beforeExit called, but process.exitCode has not been set, switch to ${code}`);
+		}
+		_shutdown(code);
 	});
 
-	process.on('unhandledRejection', (reason, _promise) => {
-		if (hasInspect) debugger;
+	function finalThrow(e: UnhandledRejection | UncaughtException) {
+		try {
+			uniqueErrorHandler(e, logger);
 
-		if (reason instanceof Error) {
-			if (reason instanceof AppExit) {
+			if (e.cause instanceof ErrorWithCode) {
+				if (!isProductionMode) logger.verbose?.(`finalThrow: got code: ${e.cause.code}`);
+				_shutdown(e.cause.code);
+			} else {
+				if (!isProductionMode) logger.verbose?.(`finalThrow: not got code: ${e.cause} `);
+				_shutdown(ExitCode.PROGRAM);
+			}
+		} catch (e: any) {
+			if (e instanceof Exit) {
 				return;
 			}
-			prettyPrintError(`${prefix}Unhandled Rejection`, reason);
-		} else {
-			console.error(`${prefix}Unhandled Rejection / error type unknown:`, reason);
+			prettyPrintError('Exception while handling error', e);
+			_shutdown(ExitCode.PROGRAM);
 		}
-		shutdown(1);
-	});
+	}
 
-	const processMdl = createRequire(import.meta.url)('node:process');
-	processMdl.exit = shutdown;
-	syncBuiltinESMExports();
+	process.on('unhandledRejection', (reason, promise) => {
+		finalThrow(new UnhandledRejection(reason, promise));
+	});
 
 	function uncaughtException(error: Error): void {
-		if (error instanceof AppExit) {
-			return;
-		}
-
-		if (hasInspect) debugger;
-
-		prettyPrintError(`${prefix}Uncaught Exception`, error);
-		shutdown(1);
+		finalThrow(new UncaughtException(error));
 	}
 
 	if (process.hasUncaughtExceptionCaptureCallback()) {
@@ -105,6 +201,9 @@ function _real_register() {
 	}
 	process.setUncaughtExceptionCaptureCallback(uncaughtException);
 
+	process.exit = shutdown;
+	syncBuiltinESMExports();
+
 	return true;
 }
 

package/src/lifecycle/workingDirectory.ts

@@ -0,0 +1,45 @@
+import { noop, vscEscapeValue } from '@idlebox/common';
+import { syncBuiltinESMExports } from 'node:module';
+import process from 'node:process';
+
+const originalChdir = process.chdir;
+const originalCwd = process.cwd;
+
+let currentEnvironmentChdir = originalChdir;
+const currentEnvironmentCwd = originalCwd;
+let patch = noop;
+
+const wd = {
+	cwd() {
+		return currentEnvironmentCwd();
+	},
+	chdir(dir: string) {
+		currentEnvironmentChdir(dir);
+	},
+	patchGlobal() {
+		patch();
+		wd.cwd = currentEnvironmentCwd;
+		wd.chdir = currentEnvironmentChdir;
+		wd.patchGlobal = noop;
+	},
+	escapeVscodeCwd,
+	isVscodeShellIntegration: process.env.VSCODE_SHELL_INTEGRATION || process.env.VSCODE_SHELL_INTEGRATION_SHELL_SCRIPT,
+};
+
+export const workingDirectory: Readonly<typeof wd> = wd;
+
+function escapeVscodeCwd(path: string) {
+	return `\x1B]633;P;Cwd=${vscEscapeValue(path)}\x07`;
+}
+
+if (wd.isVscodeShellIntegration) {
+	currentEnvironmentChdir = (newRoot: string) => {
+		process.stderr.write(escapeVscodeCwd(newRoot));
+		originalChdir(newRoot);
+	};
+	patch = () => {
+		process.chdir = currentEnvironmentChdir;
+		globalThis.process.chdir = currentEnvironmentChdir;
+		syncBuiltinESMExports();
+	};
+}