@gitkraken/core-gitlens 0.4.0 → 0.4.101

package/src/plus/integrations/utils/integration.utils.ts

@@ -7,20 +7,11 @@ import {
 } from '../constants.js';
 import type { GitHostIntegration } from '../models/gitHostIntegration.js';
 import type { Integration, IntegrationConnectedKey } from '../models/integration.js';
-import { isGitHubDotCom, isGitLabDotCom } from '../providers/models.js';
-
-// These two domain checks live here (rather than in their provider modules) to
-// break a top-level circular import. The provider modules synchronously read
-// `providersMetadata[...]` at module init time, so importing from them while
-// `providers/models.ts` is still loading triggers a TDZ on `providersMetadata`.
-const azureCloudDomainRegex = /^dev\.azure\.com$|\bvisualstudio\.com$/i;
-const bitbucketCloudDomainRegex = /^bitbucket\.org$/i;
-function isAzureCloudDomain(domain: string | undefined): boolean {
-	return domain != null && azureCloudDomainRegex.test(domain);
-}
-function isBitbucketCloudDomain(domain: string | undefined): boolean {
-	return domain != null && bitbucketCloudDomainRegex.test(domain);
-}
+// These domain checks come from `providers/models.ts` (already imported here) rather than the individual
+// provider modules: those read `providersMetadata[...]` synchronously at module init, so importing from them
+// while `providers/models.ts` is still loading triggers a TDZ on `providersMetadata`. Importing the shared
+// predicates keeps one definition of each regex — duplicating them let a fix land in only one place.
+import { isAzureCloudDomain, isBitbucketCloudDomain, isGitHubDotCom, isGitLabDotCom } from '../providers/models.js';
 
 const selfHostedIntegrationIds: GitSelfManagedHostIntegrationId[] = [
 	GitSelfManagedHostIntegrationId.CloudGitHubEnterprise,
@@ -35,8 +26,7 @@ export const supportedIntegrationIds: IntegrationIds[] = [
 	GitCloudHostIntegrationId.Bitbucket,
 	GitCloudHostIntegrationId.AzureDevOps,
 	IssuesCloudHostIntegrationId.Jira,
-	// Note: Trello is metadata-only (no auth provider), so it is intentionally absent — including it
-	// would make reset()'s ensureProvider() throw 'No authentication provider registered'.
+	IssuesCloudHostIntegrationId.Trello,
 	...selfHostedIntegrationIds,
 ] as const;
 
@@ -117,6 +107,20 @@ export function isCloudGitSelfManagedHostIntegrationId(
 	}
 }
 
+/**
+ * Whether a provider's cloud token uses `expiresIn: 0` to mean "never expires" (rather than "already
+ * expired"). GitHub and the cloud self-managed hosts always return 0 for their non-expiring tokens; Trello
+ * is issued with `expiration: never` (identity-service), so its cloud token comes back as 0 too. Callers
+ * must map 0 → a far-future expiry for these, or the session is immediately treated as expired.
+ */
+export function isNonExpiringZeroTokenIntegrationId(id: IntegrationIds): boolean {
+	return (
+		id === GitCloudHostIntegrationId.GitHub ||
+		id === IssuesCloudHostIntegrationId.Trello ||
+		isCloudGitSelfManagedHostIntegrationId(id)
+	);
+}
+
 export function isGitHostIntegration(integration: Integration): integration is GitHostIntegration {
 	return integration.type === 'git';
 }
@@ -136,3 +140,76 @@ export function isGitCloudHostIntegrationId(id: IntegrationIds): id is GitCloudH
 export function isGitSelfManagedHostIntegrationId(id: IntegrationIds): id is GitSelfManagedHostIntegrationId {
 	return selfHostedIntegrationIds.includes(id as GitSelfManagedHostIntegrationId);
 }
+
+/**
+ * Whether this id belongs to a dedicated issue tracker (resource → project) rather than a git host.
+ *
+ * Decided from the id alone, so a read can refuse a mismatched surface — a repo/PR read asked of Jira, or an
+ * issue-tracker project read asked of GitHub — before resolving a connection. The instance-level
+ * {@link isIssuesIntegration} answers the same question once an integration is in hand.
+ */
+export function isIssuesHostIntegrationId(id: IntegrationIds): id is IssuesCloudHostIntegrationId {
+	switch (id) {
+		case IssuesCloudHostIntegrationId.Jira:
+		case IssuesCloudHostIntegrationId.Linear:
+		case IssuesCloudHostIntegrationId.Trello:
+			return true;
+		default:
+			return false;
+	}
+}
+
+/**
+ * Whether a read targeted only by an explicit self-managed `domain` (no `connectionId`) must treat a
+ * session-less core result as a broken target instead of an empty account. Without this, a self-managed host
+ * addressed only by domain — the manual-token/external-auth case `domain` exists to cover — returns an empty
+ * success with no warning and no `fetchFailed`, indistinguishable from "this host has nothing".
+ */
+export function warnOnMissingSessionForDomain(id: IntegrationIds, domain: string | undefined): boolean {
+	return domain != null && isGitSelfManagedHostIntegrationId(id);
+}
+
+/** Maps an integration id to the git-remote provider type used by the remote-URL matcher. */
+export function remoteProviderTypeForIntegration(id: IntegrationIds): RemoteProviderId | undefined {
+	switch (id) {
+		case GitCloudHostIntegrationId.GitHub:
+		case GitSelfManagedHostIntegrationId.CloudGitHubEnterprise:
+			return 'github';
+		case GitCloudHostIntegrationId.GitLab:
+		case GitSelfManagedHostIntegrationId.CloudGitLabSelfHosted:
+			return 'gitlab';
+		case GitCloudHostIntegrationId.Bitbucket:
+			return 'bitbucket';
+		case GitSelfManagedHostIntegrationId.BitbucketServer:
+			return 'bitbucket-server';
+		case GitCloudHostIntegrationId.AzureDevOps:
+		case GitSelfManagedHostIntegrationId.AzureDevOpsServer:
+			return 'azure-devops';
+		default:
+			return undefined;
+	}
+}
+
+/** Normalizes a host remote-config `type` string (e.g. `'GitHub'`) to a git-remote provider type. */
+export function remoteProviderTypeForConfig(type: string): RemoteProviderId | undefined {
+	switch (type.toLowerCase()) {
+		case 'github':
+			return 'github';
+		case 'gitlab':
+			return 'gitlab';
+		case 'bitbucket':
+			return 'bitbucket';
+		case 'bitbucket-server':
+		case 'bitbucketserver':
+			return 'bitbucket-server';
+		case 'azuredevops':
+		case 'azure-devops':
+			return 'azure-devops';
+		case 'gitea':
+			return 'gitea';
+		case 'gerrit':
+			return 'gerrit';
+		default:
+			return undefined;
+	}
+}

package/src/utils/brand.ts

@@ -1,6 +1,4 @@
-// eslint-disable-next-line @typescript-eslint/naming-convention
 declare const __brand: unique symbol;
-// eslint-disable-next-line @typescript-eslint/naming-convention
 declare const __base: unique symbol;
 
 type _Brand<Base, B> = { [__brand]: B; [__base]: Base };

package/src/utils/cancellation.ts

@@ -59,6 +59,40 @@ export function raceWithSignal<T>(promise: Promise<T>, signal: AbortSignal): Pro
 	});
 }
 
+/**
+ * Races a promise against a timeout. If `ms` elapses before the promise settles, the returned promise
+ * rejects with `CancellationError`. If the promise settles first, the timer is cleared. Parallels
+ * `raceWithSignal`, with a timer standing in for the signal.
+ *
+ * When `abortOnTimeout` is provided, it is aborted on timeout — so a caller can link the underlying operation to
+ * it (e.g. via `AbortSignal.any`) and have it torn down instead of orphaned. Abort is best-effort (a truly-stuck
+ * op may ignore it); the returned promise rejects on timeout regardless of whether the underlying op settles.
+ */
+export function raceWithTimeout<T>(promise: Promise<T>, ms: number, abortOnTimeout?: AbortController): Promise<T> {
+	return new Promise<T>((resolve, reject) => {
+		const timer = setTimeout(() => {
+			const error = new CancellationError(new Error(`Timed out after ${ms}ms`));
+			abortOnTimeout?.abort(error);
+			reject(error);
+		}, ms);
+		// Don't let the timeout timer keep a (Node) process alive on its own — a still-pending promise shouldn't
+		// hold the event loop open just for its backstop (no-op in the browser, where setTimeout returns a number).
+		if (typeof timer !== 'number') {
+			timer.unref();
+		}
+		promise.then(
+			v => {
+				clearTimeout(timer);
+				resolve(v);
+			},
+			(e: unknown) => {
+				clearTimeout(timer);
+				reject(e instanceof Error ? e : new Error(String(e)));
+			},
+		);
+	});
+}
+
 /**
  * Aggregates multiple caller `AbortSignal`s into a single signal that
  * only fires when **all** callers have cancelled (the inverse of `AbortSignal.any()`).
@@ -71,7 +105,8 @@ export function raceWithSignal<T>(promise: Promise<T>, signal: AbortSignal): Pro
 export class AbortAggregate {
 	private readonly controller = new AbortController();
 	private activeCount = 0;
-	private readonly cleanups = new Map<AbortSignal, () => void>();
+	/** One listener-remover per registration (NOT keyed by signal), so adding the same signal twice is safe. */
+	private readonly cleanups = new Set<() => void>();
 
 	/** The aggregate signal — only fires when all callers have cancelled. */
 	get signal(): AbortSignal {
@@ -83,6 +118,8 @@ export class AbortAggregate {
 	 * - If `cancellation` is provided, the caller is auto-removed when it fires.
 	 * - If `cancellation` is `undefined`, the caller is "permanent" — the aggregate
 	 *   can never fire while it's active. Call the returned cleanup on promise settle.
+	 * - The same signal instance may safely be added more than once — each registration is tracked and cleaned up
+	 *   independently, so no listener leaks.
 	 * @returns A cleanup function to unregister the caller.
 	 */
 	add(cancellation?: AbortSignal): () => void {
@@ -101,17 +138,29 @@ export class AbortAggregate {
 			return () => {};
 		}
 
+		// Track this registration's listener removal individually (a Set of removers, NOT keyed by the signal) so
+		// adding the same signal twice can't overwrite the other's cleanup. `settled` keeps both exit paths (abort
+		// vs. manual cleanup) idempotent and preserves the accounting: only `onAbort` decrements `activeCount`.
+		let settled = false;
+		let remove: () => void;
 		const onAbort = () => {
-			this.cleanups.delete(cancellation);
+			if (settled) return;
+
+			settled = true;
+			this.cleanups.delete(remove);
 			this.activeCount--;
 			this.checkAbort();
 		};
+		remove = () => cancellation.removeEventListener('abort', onAbort);
 		cancellation.addEventListener('abort', onAbort, { once: true });
-		this.cleanups.set(cancellation, () => cancellation.removeEventListener('abort', onAbort));
+		this.cleanups.add(remove);
 
 		return () => {
-			this.cleanups.get(cancellation)?.();
-			this.cleanups.delete(cancellation);
+			if (settled) return;
+
+			settled = true;
+			this.cleanups.delete(remove);
+			remove();
 		};
 	}
 
@@ -123,8 +172,8 @@ export class AbortAggregate {
 
 	/** Remove all abort listeners. Call when the cached promise settles. */
 	dispose(): void {
-		for (const cleanup of this.cleanups.values()) {
-			cleanup();
+		for (const remove of this.cleanups) {
+			remove();
 		}
 		this.cleanups.clear();
 	}

package/src/utils/coalescedRun.ts

@@ -0,0 +1,45 @@
+/** Single-flight async runner with one trailing rerun: `run()` while a run is in flight joins the
+ *  SAME promise and marks it dirty; when the run settles (resolve OR reject), one trailing `refire`
+ *  fires so state that changed mid-run is re-processed. `refire` should re-enter the owner's calling
+ *  method (which applies its own gates) — fire-and-forget. `markDirty()` forces the trailing refire
+ *  (e.g. on a repo swap mid-run) without joining. */
+export class CoalescedRun<T> {
+	private _dirty = false;
+	private _inflight: Promise<T> | undefined;
+
+	constructor(
+		private readonly fn: () => Promise<T>,
+		private readonly refire: () => void,
+	) {}
+
+	get running(): boolean {
+		return this._inflight != null;
+	}
+
+	markDirty(): void {
+		if (this._inflight != null) {
+			this._dirty = true;
+		}
+	}
+
+	run(): Promise<T> {
+		if (this._inflight != null) {
+			this._dirty = true;
+			return this._inflight;
+		}
+
+		// Defer `fn` to a microtask so `_inflight` is assigned BEFORE any of fn's code runs — a
+		// synchronous reentrant `run()` from fn's prologue then joins instead of double-running.
+		const promise = Promise.resolve()
+			.then(this.fn)
+			.finally(() => {
+				this._inflight = undefined;
+				if (this._dirty) {
+					this._dirty = false;
+					this.refire();
+				}
+			});
+		this._inflight = promise;
+		return promise;
+	}
+}

package/src/utils/color.ts

@@ -344,15 +344,15 @@ export class Color {
 	static from(value: string | Color): Color {
 		if (value instanceof Color) return value;
 
-		return parseColor(value) || Color.red;
+		return parseColor(value) ?? Color.red;
 	}
 
 	static fromCssVariable(variable: string, css: { getPropertyValue(property: string): string }): Color {
-		return parseColor(getCssVariable(variable, css)) || Color.red;
+		return parseColor(getCssVariable(variable, css)) ?? Color.red;
 	}
 
 	static fromHex(hex: string): Color {
-		return parseHexColor(hex) || Color.red;
+		return parseHexColor(hex) ?? Color.red;
 	}
 
 	static equals(a: Color | null, b: Color | null): boolean {

package/src/utils/date.ts

@@ -11,6 +11,15 @@ const relativeUnitThresholds: [Intl.RelativeTimeFormatUnit, number, number, stri
 	['minute', 60 * 1000, 60 * 1000, 'm'],
 	['second', 1000, 1000, 's'],
 ];
+// Built ONCE from the table above (not per-call `.find()` scans, and not a Map — plain object property
+// reads are monomorphic/faster than Map.get for this) — backs unitDivisorMs/unitThresholdMs below. Never
+// touched on fromNow's own hot path (see the loop in fromNow itself).
+const unitDivisors: Partial<Record<Intl.RelativeTimeFormatUnit, number>> = {};
+const unitThresholds: Partial<Record<Intl.RelativeTimeFormatUnit, number>> = {};
+for (const [unit, threshold, divisor] of relativeUnitThresholds) {
+	unitDivisors[unit] = divisor;
+	unitThresholds[unit] = threshold;
+}
 
 type DateStyle = 'full' | 'long' | 'medium' | 'short';
 type TimeStyle = 'full' | 'long' | 'medium' | 'short';
@@ -78,6 +87,69 @@ export function createFromDateDelta(
 	return d;
 }
 
+/** The unit + truncated magnitude `fromNow` would pick for `date` relative to `now` — same threshold
+ *  table + truncation `fromNow` formats with, factored out so a caller that needs to CLASSIFY a date
+ *  (not just format it) can't drift from what the column actually displays. Allocation-free (no `Date`
+ *  construction — both `date` and `now` are read as epoch ms when passed as numbers). `now` defaults to
+ *  `Date.now()`; a caller classifying many rows against the SAME instant should pass it explicitly. */
+export function fromNowUnit(
+	date: Date | number,
+	now: Date | number = Date.now(),
+): { unit: Intl.RelativeTimeFormatUnit; value: number } | undefined {
+	const elapsed =
+		(typeof date === 'number' ? date : date.getTime()) - (typeof now === 'number' ? now : now.getTime());
+	// Guard against invalid dates (e.g. `new Date(<unparseable>)`) — mirrors fromNow's own guard.
+	if (!Number.isFinite(elapsed)) return undefined;
+
+	const elapsedABS = Math.abs(elapsed);
+	for (const [unit, threshold, divisor] of relativeUnitThresholds) {
+		if (elapsedABS >= threshold || threshold === 1000 /* second */) {
+			return { unit: unit, value: Math.trunc(elapsed / divisor) };
+		}
+	}
+	return undefined;
+}
+
+/** Allocation-free sibling of `fromNowUnit` for a caller that only needs to CLASSIFY (compare two dates'
+ *  groups) rather than build the `{unit,value}` object — same loop over the same table, so it can't
+ *  drift from `fromNowUnit`/`fromNow`. Encodes the result as `unitOrdinal*100000 + truncValue` (ordinal
+ *  0 = 'year' … 6 = 'second', matching `relativeUnitThresholds`' order; `truncValue` keeps its sign, so
+ *  a positive result means `date` is in the FUTURE relative to `now`). */
+export function fromNowUnitKey(date: Date | number, now: Date | number = Date.now()): number | undefined {
+	const elapsed =
+		(typeof date === 'number' ? date : date.getTime()) - (typeof now === 'number' ? now : now.getTime());
+	if (!Number.isFinite(elapsed)) return undefined;
+
+	const elapsedABS = Math.abs(elapsed);
+	let ordinal = 0;
+	for (const [, threshold, divisor] of relativeUnitThresholds) {
+		if (elapsedABS >= threshold || threshold === 1000 /* second */) {
+			return ordinal * 100_000 + Math.trunc(elapsed / divisor);
+		}
+
+		ordinal++;
+	}
+	return undefined;
+}
+
+/** The divisor (ms) `fromNowUnit` divides elapsed time by for `unit` — i.e. the elapsed-ms width one
+ *  step of `value` represents. Exported so a caller reconstructing a `fromNowUnit` result's elapsed
+ *  WINDOW (its start/end bounds) doesn't have to re-derive the thresholds table itself. */
+export function unitDivisorMs(unit: Intl.RelativeTimeFormatUnit): number {
+	return unitDivisors[unit] ?? 0;
+}
+
+/** The elapsed-ms THRESHOLD `fromNowUnit` requires to classify into `unit` at all (only differs from
+ *  `unitDivisorMs` for 'year' — see the table above). Exported so a caller clamping a group's elapsed
+ *  window to where the NEXT unit actually takes over (not just `n+1` steps of the same divisor) can read
+ *  the real cutover point instead of re-deriving the thresholds table itself. */
+export function unitThresholdMs(unit: Intl.RelativeTimeFormatUnit): number {
+	return unitThresholds[unit] ?? 0;
+}
+
+// fromNow keeps its OWN single-pass loop (not routed through fromNowUnit) — one iteration, no
+// intermediate {unit,value} object allocation on this hot formatting path; fromNowUnit below iterates
+// the SAME `relativeUnitThresholds` array, so the two classifications can't drift apart.
 export function fromNow(date: Date | number, short?: boolean): string {
 	const elapsed = (typeof date === 'number' ? date : date.getTime()) - Date.now();
 	// Guard against invalid dates (e.g. `new Date(<unparseable>)`), since a non-finite value would throw in `Intl.RelativeTimeFormat.format`

package/src/utils/debounce.ts

@@ -276,7 +276,7 @@ export function debounce<F extends (...args: any[]) => ReturnType<F>>(
 		if (aggregator != null && lastArgs != null) {
 			lastArgs = aggregator(lastArgs, args);
 		} else {
-			// oxlint-disable-next-line @typescript-eslint/no-this-alias
+			// oxlint-disable-next-line typescript/no-this-alias
 			lastThis = this;
 			lastArgs = args;
 		}

package/src/utils/decorators/gate.ts

@@ -1,4 +1,4 @@
-/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* oxlint-disable typescript/no-unsafe-return */
 import { CancellationError } from '../cancellation.js';
 import type { UnifiedDisposable } from '../disposable.js';
 import { createDisposable } from '../disposable.js';
@@ -28,7 +28,7 @@ export function gate<T extends (...args: any[]) => any>(
 	timeout ??= 300000;
 
 	return (_target: any, key: string, descriptor: PropertyDescriptor): void => {
-		// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+		// oxlint-disable-next-line typescript/no-unsafe-function-type
 		let fn: Function | undefined;
 		if (typeof descriptor.value === 'function') {
 			fn = descriptor.value;

package/src/utils/decorators/log.ts

@@ -1,4 +1,4 @@
-/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* oxlint-disable typescript/no-unsafe-return */
 import { getParameters } from '../function.js';
 import { getDurationMilliseconds, hrtime } from '../hrtime.js';
 import type { LogLevel } from '../logger.js';
@@ -38,9 +38,9 @@ interface LogOptions<T extends (...args: any[]) => any> {
 }
 
 // Using Function type to support classes with private/protected constructors
-// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+// oxlint-disable-next-line typescript/no-unsafe-function-type
 export function logName<T>(fn: (c: T, name: string) => string): (target: Function & { prototype: T }) => void {
-	// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+	// oxlint-disable-next-line typescript/no-unsafe-function-type
 	return (target: (abstract new (...args: any[]) => T) | (Function & { prototype: T })): void =>
 		void customLoggableNameFns.set(target, fn);
 }
@@ -54,7 +54,7 @@ export function logName<T>(fn: (c: T, name: string) => string): (target: Functio
  * Defaults to `id` if the instance has one, otherwise just `ClassName`.
  */
 export function loggable<T extends object>(fn?: (instance: T) => string) {
-	// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+	// oxlint-disable-next-line typescript/no-unsafe-function-type
 	return (target: (abstract new (...args: any[]) => T) | (Function & { prototype: T })): void => {
 		target.prototype.toLoggable = function (this: T): string {
 			const name = getLoggableName(this);
@@ -105,7 +105,7 @@ function log<T extends (...arg: any[]) => any>(
 		logLevel === 'trace' ? Logger.trace : logLevel === 'debug' ? Logger.debug : Logger.info;
 
 	return (_target: any, key: string, descriptor: PropertyDescriptor & Record<string, any>) => {
-		// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+		// oxlint-disable-next-line typescript/no-unsafe-function-type
 		let fn: Function | undefined;
 		let fnKey: string | undefined;
 		if (typeof descriptor.value === 'function') {

package/src/utils/decorators/memoize.ts

@@ -1,4 +1,4 @@
-/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* oxlint-disable typescript/no-unsafe-return */
 import { resolveProp } from './resolver.js';
 
 /** Keys for memoize version invalidation */
@@ -43,7 +43,7 @@ export function memoize<T extends (...args: any[]) => any>(
 	const opts = options ?? {};
 
 	return (_target: any, key: string, descriptor: PropertyDescriptor & Record<string, any>): void => {
-		// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+		// oxlint-disable-next-line typescript/no-unsafe-function-type
 		let fn: Function | undefined;
 		let fnKey: string | undefined;
 

package/src/utils/decorators/sequentialize.ts

@@ -43,7 +43,7 @@ export function sequentialize<T extends (...args: any[]) => any>(
 	const getDedupingKey = options?.getDedupingKey;
 
 	return (_target: any, key: string, descriptor: PropertyDescriptor) => {
-		// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+		// oxlint-disable-next-line typescript/no-unsafe-function-type
 		let fn: Function | undefined;
 		if (typeof descriptor.value === 'function') {
 			fn = descriptor.value;
@@ -69,7 +69,7 @@ export function sequentialize<T extends (...args: any[]) => any>(
 			}
 
 			const state: SequentializeState | undefined = this[prop];
-			// eslint-disable-next-line @typescript-eslint/no-unsafe-return
+			// oxlint-disable-next-line typescript/no-unsafe-return
 			const run = async () => await fn.apply(this, args);
 
 			// Compute the dedupe key once

package/src/utils/decorators/serializable.ts

@@ -1,4 +1,4 @@
-/* eslint-disable @typescript-eslint/no-unsafe-function-type */
+/* oxlint-disable typescript/no-unsafe-function-type */
 
 /**
  * Class decorator that adds a `toJSON()` method materializing all prototype getters into the

package/src/utils/env/node/exec.ts

@@ -277,9 +277,9 @@ export function run<T extends number | string>(
 					let stderrDecoded: string;
 					if (encoding === 'utf8' || encoding === 'binary' || encoding === 'buffer') {
 						// stdout & stderr can be `Buffer` or `string
-						// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-conversion
+						// oxlint-disable-next-line typescript/no-unnecessary-type-conversion
 						stdoutDecoded = stdout.toString();
-						// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-conversion
+						// oxlint-disable-next-line typescript/no-unnecessary-type-conversion
 						stderrDecoded = stderr.toString();
 					} else {
 						if (decode == null) {
@@ -332,7 +332,15 @@ export function run<T extends number | string>(
 }
 
 export interface RunExitResult {
-	exitCode: number;
+	/**
+	 * The process's exit code. ABSENT when the process never exited normally — killed by a signal, in which
+	 * case {@link signal} is set. Deliberately optional rather than defaulted to `0`: a signalled process
+	 * reported as `exitCode: 0` is indistinguishable from a clean success, so callers would read a partial
+	 * or empty stdout as a complete answer.
+	 */
+	readonly exitCode?: number;
+	/** Set when the process was terminated by a signal instead of exiting; {@link exitCode} is then absent. */
+	readonly signal?: NodeJS.Signals;
 }
 
 export interface RunResult<T extends string | Buffer> extends RunExitResult {
@@ -412,7 +420,11 @@ export function runSpawn<T extends string | Buffer>(
 
 		proc.once('close', async (code, signal) => {
 			if (options?.exitCodeOnly) {
-				resolve({ exitCode: code ?? 0 });
+				// Resolves unconditionally, so this is the one path that can hand back a signalled run. `code`
+				// is null exactly when the process was killed — report the signal rather than coercing to `0`,
+				// which would claim a clean success for a command that never finished. Note this returns BEFORE
+				// the SIGTERM-to-cancellation diversion below, so callers have to classify that themselves.
+				resolve({ exitCode: code ?? undefined, signal: signal ?? undefined });
 
 				return;
 			}
@@ -453,7 +465,10 @@ export function runSpawn<T extends string | Buffer>(
 				);
 			}
 
-			resolve({ exitCode: code ?? 0, stdout: stdout, stderr: stderr });
+			// The guard above already rejected every non-zero and every signalled close, so this is a clean
+			// zero exit — `code` cannot be null here. (The optional typing exists for the `exitCodeOnly`
+			// branch, which is where a codeless result can genuinely surface.)
+			resolve({ exitCode: code ?? undefined, signal: signal ?? undefined, stdout: stdout, stderr: stderr });
 		});
 
 		if (stdin) {

package/src/utils/event.ts

@@ -17,36 +17,30 @@ export class Emitter<T> {
 	 * to events from this Emitter
 	 */
 	get event(): Event<T> {
-		if (!this._event) {
-			this._event = (listener: (e: T) => any, thisArgs?: unknown, disposables?: { dispose(): void }[]) => {
-				if (this._disposed) {
-					return createDisposable(() => {});
-				}
+		this._event ??= (listener: (e: T) => any, thisArgs?: unknown, disposables?: { dispose(): void }[]) => {
+			if (this._disposed) {
+				return createDisposable(() => {});
+			}
 
-				if (!this._listeners) {
-					this._listeners = [];
-				}
+			this._listeners ??= [];
 
-				this._listeners.push({ callback: listener, thisArgs: thisArgs });
+			this._listeners.push({ callback: listener, thisArgs: thisArgs });
 
-				const result = createDisposable(() => {
-					if (!this._disposed && this._listeners) {
-						const index = this._listeners.findIndex(
-							l => l.callback === listener && l.thisArgs === thisArgs,
-						);
-						if (index > -1) {
-							this._listeners.splice(index, 1);
-						}
+			const result = createDisposable(() => {
+				if (!this._disposed && this._listeners) {
+					const index = this._listeners.findIndex(l => l.callback === listener && l.thisArgs === thisArgs);
+					if (index > -1) {
+						this._listeners.splice(index, 1);
 					}
-				});
-
-				if (disposables instanceof Array) {
-					disposables.push(result);
 				}
+			});
 
-				return result;
-			};
-		}
+			if (disposables instanceof Array) {
+				disposables.push(result);
+			}
+
+			return result;
+		};
 		return this._event;
 	}
 
@@ -155,7 +149,7 @@ export function promisifyDeferred<T, U>(
 			} catch (ex) {
 				pending = false;
 
-				// eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
+				// oxlint-disable-next-line typescript/prefer-promise-reject-errors
 				reject(ex);
 			}
 		});

package/src/utils/function.ts

@@ -8,7 +8,7 @@ const fnBodyRegex = /\(([\s\S]*)\)/;
 const fnBodyStripCommentsRegex = /(\/\*([\s\S]*?)\*\/|([^:]|^)\/\/(.*)$)/gm;
 const fnBodyStripParamDefaultValueRegex = /\s?=.*$/;
 
-// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+// oxlint-disable-next-line typescript/no-unsafe-function-type
 export function getParameters(fn: Function): string[] {
 	if (typeof fn !== 'function') throw new Error('Not supported');
 
@@ -73,7 +73,7 @@ export function partial<T extends (...args: any[]) => any, P extends any[]>(
 	fn: T,
 	...partialArgs: PartialArgs<Parameters<T>, P>
 ): (...rest: DropFirstN<Parameters<T>, P['length']>) => ReturnType<T> {
-	// eslint-disable-next-line @typescript-eslint/no-unsafe-return
+	// oxlint-disable-next-line typescript/no-unsafe-return
 	return (...rest) => fn(...partialArgs, ...rest);
 }
 
@@ -93,7 +93,7 @@ export function sequentialize<T extends (...args: any[]) => Promise<any>>(fn: T)
 	let promise: Promise<unknown> | undefined;
 
 	return function (...args: any[]): Promise<any> {
-		// eslint-disable-next-line @typescript-eslint/no-unsafe-return
+		// oxlint-disable-next-line typescript/no-unsafe-return
 		const run = async () => await fn(...args);
 		if (promise == null) {
 			promise = run();