@gitkraken/core-gitlens 0.3.0 → 0.3.1

package/src/plus/agents/types.ts

@@ -135,22 +135,46 @@ export interface AgentSession {
 	 *  identity. For "what repo is this session in", use {@link commonPath}. */
 	readonly workspacePath?: string;
 	readonly cwd?: string;
+	/** The session's `cwd` at first observation. Set once and never overwritten — captures the
+	 *  agent's launch directory so consumers can detect drift (e.g. an agent that `cd`'d into a
+	 *  sibling worktree). Pairs with {@link initialWorktreePath} / {@link initialCommonPath}; for
+	 *  the live cwd, see {@link cwd}. */
+	readonly initialCwd?: string;
+	/** The session's `worktreePath` at first successful git-info resolution. Set once and never
+	 *  overwritten — compare against {@link worktreePath} to detect cross-worktree drift. Undefined
+	 *  if the session has never resolved into a git repo. */
+	readonly initialWorktreePath?: string;
+	/** The session's `commonPath` at first successful git-info resolution. Set once and never
+	 *  overwritten — compare against {@link commonPath} to detect cross-repo drift. Undefined if
+	 *  the session has never resolved into a git repo. */
+	readonly initialCommonPath?: string;
 	readonly planFile?: string;
 	readonly isInWorkspace: boolean;
 	readonly lastPrompt?: string;
 	readonly firstPrompt?: string;
-	/** Absolute paths of files targeted by in-flight file-editing tool calls (Edit/Write/MultiEdit/
-	 *  NotebookEdit). Populated on PreToolUse, drained on PostToolUse/PermissionDenied, cleared on
-	 *  Stop/SessionEnd. Empty/undefined when no file-editing tool is active.
+	/** Per-file activity record covering both read-class (Read/NotebookRead) and edit-class
+	 *  (Edit/Write/MultiEdit/NotebookEdit) tool calls. Populated on PreToolUse; each path is retained
+	 *  and fades for the configured decay window measured from its own last PostToolUse — the tail
+	 *  survives the turn-end Stop (which only drops the live `editing`/`reading` flags) and is fully
+	 *  cleared only on SessionEnd or once the decay window elapses.
 	 *
-	 *  Mutable array form so `Shape<AgentSession>` projects it as `string[]` (the `Shape<>` type
-	 *  mangles `readonly T[]` into a mapped object that loses its iterator). Treat as immutable. */
-	currentFiles?: string[];
-	/** Absolute paths of files the agent recently *read* (Read/NotebookRead). Populated on
-	 *  PreToolUse, drained on PostToolUse/PermissionDenied with the same cooldown as
-	 *  `currentFiles`. Distinct from `currentFiles` which tracks write-class tools so consumers can
-	 *  visualize "looking at" vs "working on" differently. Treat as immutable. */
-	currentReads?: string[];
+	 *  A sub-agent's file activity appears on its PARENT's `fileActivity`, not the sub-agent's own:
+	 *  the GK CLI keys a sub-agent's tool events under the parent session id (with `agentId` set), so
+	 *  they accumulate in the parent's bookkeeping directly. Consumers never need to recurse into
+	 *  `subagents[]`; sub-agent `AgentSession` objects carry `fileActivity: undefined`.
+	 *
+	 *  Field semantics:
+	 *  - `path`: absolute path on the agent's filesystem.
+	 *  - `readAt` / `editedAt`: milliseconds since the last PreToolUse for that kind, computed by
+	 *    the host at serialization time (relative — avoids clock-skew). Omitted when never touched
+	 *    by that kind within the window.
+	 *  - `reading` / `editing`: `true` when at least one tool of that kind is in flight on this
+	 *    path right now (refcount > 0 in the host bookkeeping). Omitted when false to keep the
+	 *    wire minimal.
+	 *
+	 *  Mutable array form so `Shape<AgentSession>` projects it cleanly (the `Shape<>` type mangles
+	 *  `readonly T[]` into a mapped object that loses its iterator). Treat as immutable. */
+	fileActivity?: { path: string; readAt?: number; editedAt?: number; reading?: true; editing?: true }[];
 	/** `true` when the session was discovered via peer IPC sync (i.e. another GitLens window hosts
 	 *  the agent's hook flow and Claude Code extension panel). Locally-owned sessions leave this
 	 *  unset. The dispatcher uses this to route opens through the peer's IPC route + an OS-level
@@ -186,6 +210,11 @@ export interface AgentSessionProvider extends UnifiedDisposable {
 	stop(): void;
 	updateWorkspacePaths?(workspacePaths: string[]): void;
 
+	/** Pushed by the host from its cached agent detection. Lets the provider gate its reconciliation
+	 *  poll (the CLI `list-sessions` call) so an idle window with no sessions and no installed hooks
+	 *  doesn't spawn the CLI every interval. */
+	setClaudeHooksInstalled?(installed: boolean): void;
+
 	/** Resolves a pending permission. Returns `true` when the resolve was routed (the local IPC
 	 *  owns the session's pending entry); `false` when no local entry exists (typically a peer-
 	 *  discovered session owned by another GitLens window). Callers use this to give the user
@@ -231,6 +260,13 @@ export interface AgentProviderCallbacks {
 	/** Host-supplied IPC service. Required for agents to receive hook events from the GK CLI. */
 	ipc: IpcRegistrar;
 
+	/** Returns the current "activity decay" window in milliseconds — the cooldown between a tool
+	 *  call finishing and the file being dropped from `AgentSession.fileActivity`. Optional — when
+	 *  omitted the provider falls back to its built-in default (5 min). Read by the provider at
+	 *  schedule time so changes to the host setting take effect on the next tool call without
+	 *  needing a re-wiring step. */
+	getActivityDecayMs?(): number;
+
 	/** Report that an agent session started. No-op if the host has no telemetry. */
 	onSessionStarted?(provider: string): void;
 
@@ -240,6 +276,18 @@ export interface AgentProviderCallbacks {
 	/** Report that a permission request was resolved. No-op if the host has no telemetry. */
 	onPermissionResolved?(info: { provider: string; tool: string; decision: PermissionDecision }): void;
 
+	/** Report that a reconciliation poll found the polled session set drift from what the live IPC
+	 *  path had already tracked — `discovered` sessions the poll saw but we weren't tracking,
+	 *  `missing` sessions we track that the poll no longer reports alive. Ideally always zero. No-op
+	 *  if the host has no telemetry. */
+	onSyncDiscrepancy?(info: {
+		provider: string;
+		discovered: number;
+		missing: number;
+		polled: number;
+		tracked: number;
+	}): void;
+
 	/** Notify the host that a branch has agent activity. */
 	onBranchAgentActivity?(cwd: string): void;
 

package/src/plus/ai/models/model.ts

@@ -28,6 +28,7 @@ export type AIActionType =
 	| 'generate-changelog'
 	| `generate-create-${'cloudPatch' | 'codeSuggestion' | 'pullRequest'}`
 	| 'generate-commits'
+	| 'conflict-resolution'
 	| 'generate-searchQuery';
 
 export interface AIProviderDescriptor<T extends AIProviders = AIProviders> {

package/src/plus/ai/models/provider.ts

@@ -47,6 +47,12 @@ export interface AIProvider<Provider extends AIProviders = AIProviders> extends
 		model: AIModel<Provider>,
 		apiKey: string,
 		getMessages: (maxInputTokens: number, retries: number) => Promise<AIChatMessage[]>,
-		options: { signal: AbortSignal; modelOptions?: { outputTokens?: number; temperature?: number } },
+		options: {
+			signal: AbortSignal;
+			modelOptions?: { outputTokens?: number; temperature?: number };
+			/** Opaque session ID the GitKraken provider sends as `GK-Conversation-ID` so the backend
+			 *  charges its per-feature fee once per session; ignored by all other providers. */
+			conversationId?: string;
+		},
 	): Promise<AIProviderResponse<void> | undefined>;
 }

package/src/plus/ai/providers/gitkrakenProvider.ts

@@ -87,11 +87,15 @@ export class GitKrakenProvider extends OpenAICompatibleProviderBase<typeof provi
 		apiKey: string,
 		_model: AIModel<typeof provider.id>,
 		_url: string,
+		conversationId?: string,
 	): Record<string, string> {
 		return {
 			Accept: 'application/json',
 			Authorization: `Bearer ${apiKey}`,
 			'GK-Action': action,
+			// Scopes the backend's once-per-conversation feature fee — without it every request in a
+			// multi-call session (e.g. conflict resolution) is charged the full flat fee.
+			...(conversationId ? { 'GK-Conversation-ID': conversationId } : {}),
 		};
 	}
 

package/src/plus/ai/providers/openAICompatibleProviderBase.ts

@@ -61,6 +61,9 @@ export abstract class OpenAICompatibleProviderBase<T extends AIProviders> implem
 		apiKey: string,
 		_model: AIModel<T>,
 		_url: string,
+		// Deliberately unused here: only the GitKraken provider forwards the conversation ID (as
+		// `GK-Conversation-ID`); it must never reach third-party APIs.
+		_conversationId?: string,
 	): Record<string, string> | Promise<Record<string, string>> {
 		return {
 			Accept: 'application/json',
@@ -74,12 +77,24 @@ export abstract class OpenAICompatibleProviderBase<T extends AIProviders> implem
 		model: AIModel<T>,
 		apiKey: string,
 		getMessages: (maxInputTokens: number, retries: number) => Promise<AIChatMessage[]>,
-		options: { signal: AbortSignal; modelOptions?: { outputTokens?: number; temperature?: number } },
+		options: {
+			signal: AbortSignal;
+			modelOptions?: { outputTokens?: number; temperature?: number };
+			conversationId?: string;
+		},
 	): Promise<AIProviderResponse<void> | undefined> {
 		using scope = maybeStartScopedLogger(`${getLoggableName(this)}.sendRequest`);
 
 		try {
-			const result = await this.fetch(action, model, apiKey, getMessages, options.modelOptions, options.signal);
+			const result = await this.fetch(
+				action,
+				model,
+				apiKey,
+				getMessages,
+				options.modelOptions,
+				options.signal,
+				options.conversationId,
+			);
 			return result;
 		} catch (ex) {
 			if (isCancellationError(ex)) {
@@ -104,6 +119,7 @@ export abstract class OpenAICompatibleProviderBase<T extends AIProviders> implem
 		messages: (maxInputTokens: number, retries: number) => Promise<AIChatMessage[]>,
 		modelOptions?: { outputTokens?: number; temperature?: number },
 		signal?: AbortSignal,
+		conversationId?: string,
 	): Promise<AIProviderResponse<void>> {
 		let retries = 0;
 		let maxInputTokens = model.maxTokens.input;
@@ -123,7 +139,7 @@ export abstract class OpenAICompatibleProviderBase<T extends AIProviders> implem
 				),
 			};
 
-			const rsp = await this.fetchCore(action, model, apiKey, request, signal);
+			const rsp = await this.fetchCore(action, model, apiKey, request, signal, conversationId);
 			if (!rsp.ok) {
 				const result = await this.handleFetchFailure(rsp, action, model, retries, maxInputTokens);
 				if (result.retry) {
@@ -207,6 +223,7 @@ export abstract class OpenAICompatibleProviderBase<T extends AIProviders> implem
 		apiKey: string,
 		request: object,
 		signal: AbortSignal | undefined,
+		conversationId?: string,
 	): Promise<Response> {
 		const url = this.getUrl(model);
 		if (!url) {
@@ -215,7 +232,7 @@ export abstract class OpenAICompatibleProviderBase<T extends AIProviders> implem
 
 		try {
 			return await this.context.fetch(url, {
-				headers: await this.getHeaders(action, apiKey, model, url),
+				headers: await this.getHeaders(action, apiKey, model, url, conversationId),
 				method: 'POST',
 				body: JSON.stringify(request),
 				signal: signal,

package/src/plus/ai/utils/ai.utils.ts

@@ -20,6 +20,8 @@ export function getActionName(action: AIActionType): string {
 			return 'Create Pull Request Details (Preview)';
 		case 'generate-commits':
 			return 'Generate Commits (Preview)';
+		case 'conflict-resolution':
+			return 'Resolve Conflicts with AI (Preview)';
 		case 'generate-searchQuery':
 			return 'Generate Search Query (Preview)';
 	}

package/src/plus/git-github/api/github.ts

@@ -74,6 +74,46 @@ interface CancellationToken {
 const emptyPagedResult: PagedResult<any> = Object.freeze({ values: [] });
 const emptyBlameResult: GitHubBlame = Object.freeze({ ranges: [] });
 
+// Transient gateway/network failures (e.g. an upstream `502 Bad Gateway`) are worth a few quick
+// retries before surfacing to the caller. octokit provides no built-in retry for the standalone
+// `request`/`graphql` functions we use (its retry/throttle plugins only attach to the `Octokit`
+// class), so we retry here — but only for idempotent reads (REST GET/HEAD, GraphQL queries),
+// never for mutations.
+const maxRequestRetries = 2;
+const requestRetryBaseDelay = 300; // ms
+const requestRetryMaxDelay = 2000; // ms
+
+function isRetryableTransientError(ex: unknown): ex is RequestError {
+	// An aborted request is rethrown as the original `AbortError` (not a `RequestError`), so it is
+	// excluded here. octokit maps a fetch/network failure to a `RequestError` with status 500 and
+	// no response — those, along with real gateway statuses, are transient and safe to retry.
+	if (!(ex instanceof RequestError)) return false;
+
+	switch (ex.status) {
+		case 502: // Bad Gateway
+		case 503: // Service Unavailable
+		case 504: // Gateway Timeout
+			return true;
+		case 500: // Internal Server Error — only the network-failure variant (no response)
+			return ex.response == null;
+		default:
+			return false;
+	}
+}
+
+function getRequestRetryDelay(attempt: number): number {
+	// Exponential backoff with equal jitter, capped — spreads retries so a brief upstream blip
+	// isn't hammered by every in-flight request landing on the same schedule.
+	const backoff = Math.min(requestRetryMaxDelay, requestRetryBaseDelay * 2 ** (attempt - 1));
+	return Math.round(backoff / 2 + Math.random() * (backoff / 2));
+}
+
+// Matches a GraphQL document whose operation is definitely a read query — the `query` keyword as
+// the first significant token, after any leading whitespace or `#` comment lines. We retry only
+// when this matches; a mutation (even one prefixed by a comment), a subscription, or anything we
+// can't classify is left non-retryable so a transient failure can never re-run a mutation.
+const graphqlReadQueryRegex = /^(?:\s|#[^\n]*\n?)*query\b/;
+
 const gqlIssueOrPullRequestFragment = `
 closed
 closedAt
@@ -2866,6 +2906,55 @@ export class GitHubApi {
 		return version ?? undefined;
 	}
 
+	// Runs `execute`, retrying transient gateway/network failures with backoff. `retryable` gates
+	// retries to idempotent reads; `signal` lets an in-flight cancellation abort the backoff wait.
+	private async requestWithRetries<T>(
+		execute: () => Promise<T>,
+		retryable: boolean,
+		signal: AbortSignal | undefined,
+		scope: ScopedLogger | undefined,
+	): Promise<T> {
+		let attempt = 0;
+		while (true) {
+			try {
+				return await execute();
+			} catch (ex) {
+				if (!retryable || attempt >= maxRequestRetries || signal?.aborted || !isRetryableTransientError(ex)) {
+					throw ex;
+				}
+
+				attempt++;
+				const delay = getRequestRetryDelay(attempt);
+				scope?.warn(
+					`Transient request failure (status ${ex.status}); retrying ${attempt}/${maxRequestRetries} in ${delay}ms`,
+				);
+				await this.delayWithAbort(delay, signal);
+				// Bail rather than retry if we were cancelled while waiting
+				if (signal?.aborted) throw new CancellationError();
+			}
+		}
+	}
+
+	private delayWithAbort(ms: number, signal: AbortSignal | undefined): Promise<void> {
+		return new Promise<void>(resolve => {
+			if (signal?.aborted) {
+				resolve();
+				return;
+			}
+
+			let timer: ReturnType<typeof setTimeout>;
+			const onAbort = () => {
+				clearTimeout(timer);
+				resolve();
+			};
+			timer = setTimeout(() => {
+				signal?.removeEventListener('abort', onAbort);
+				resolve();
+			}, ms);
+			signal?.addEventListener('abort', onAbort, { once: true });
+		});
+	}
+
 	// Inflight dedupe: identical concurrent GraphQL requests share a single promise
 	// to cut redundant traffic during graph/details enrichment bursts.
 	private readonly _pendingGraphQL = new Map<string, Promise<unknown>>();
@@ -2912,8 +3001,17 @@ export class GitHubApi {
 					};
 				}
 
-				return await this.config.wrapForForcedInsecureSSL(provider?.getIgnoreSSLErrors() ?? false, () =>
-					this.getDefaults(accessToken, graphql)(query, variables),
+				// Retry transient gateway/network failures, but only confirmed read queries — never
+				// mutations (re-running one isn't idempotent)
+				const retryable = graphqlReadQueryRegex.test(query);
+				return await this.requestWithRetries(
+					() =>
+						this.config.wrapForForcedInsecureSSL(provider?.getIgnoreSSLErrors() ?? false, () =>
+							this.getDefaults(accessToken, graphql)(query, variables),
+						),
+					retryable,
+					aborter?.signal,
+					scope,
 				);
 			} catch (ex) {
 				if (ex instanceof GraphqlResponseError) {
@@ -2955,12 +3053,15 @@ export class GitHubApi {
 		const promise = run();
 		this._pendingGraphQL.set(dedupeKey, promise);
 		// Clear from the inflight map once the promise settles — successes and failures both
-		// clear, so failed requests don't poison subsequent retries.
-		void promise.finally(() => {
+		// clear, so failed requests don't poison subsequent retries. Use `then(cleanup, cleanup)`
+		// rather than `finally` so a rejected request doesn't spawn an orphaned (unhandled) promise;
+		// the real caller still receives the rejection via the returned `promise`.
+		const cleanup = () => {
 			if (this._pendingGraphQL.get(dedupeKey) === promise) {
 				this._pendingGraphQL.delete(dedupeKey);
 			}
-		});
+		};
+		promise.then(cleanup, cleanup);
 		return promise;
 	}
 
@@ -2974,16 +3075,27 @@ export class GitHubApi {
 	): Promise<Endpoints[R]['response']> {
 		const { accessToken } = token;
 		try {
+			let signal: AbortSignal | undefined;
 			if (cancellation != null) {
 				if (cancellation.isCancellationRequested) throw new CancellationError();
 
 				const aborter = new AbortController();
 				cancellation.onCancellationRequested(() => aborter.abort());
-				options = { ...options, request: { ...options?.request, signal: aborter.signal } };
+				signal = aborter.signal;
+				options = { ...options, request: { ...options?.request, signal: signal } };
 			}
 
-			return (await this.config.wrapForForcedInsecureSSL(provider?.getIgnoreSSLErrors() ?? false, () =>
-				this.getDefaults(accessToken, request)(route as string, options),
+			// Retry transient gateway/network failures on idempotent reads only
+			const method = route.split(' ', 1)[0].toUpperCase();
+			const retryable = method === 'GET' || method === 'HEAD';
+			return (await this.requestWithRetries(
+				() =>
+					this.config.wrapForForcedInsecureSSL(provider?.getIgnoreSSLErrors() ?? false, () =>
+						this.getDefaults(accessToken, request)(route as string, options),
+					),
+				retryable,
+				signal,
+				scope,
 			)) as Endpoints[R]['response'];
 		} catch (ex) {
 			if (ex instanceof RequestError || ex.name === 'AbortError') {

package/src/plus/git-github/providers/github/refs.ts

@@ -17,7 +17,7 @@ import { toTokenInfo } from '../../api/tokenUtils.js';
 import type { GitHubGitProviderInternal } from '../githubProvider.js';
 
 // Since negative lookbehind isn't supported in all browsers, this leaves out the negative lookbehind condition `(?<!\.lock)` to ensure the branch name doesn't end with `.lock`
-// eslint-disable-next-line no-control-regex
+// oxlint-disable-next-line no-control-regex
 const validBranchOrTagRegex = /^[^/](?!.*\/\.)(?!.*\.\.)(?!.*\/\/)(?!.*@\{)[^\x00-\x1F\x7F ~^:?*[\\]+[^./]$/;
 
 export class RefsGitSubProvider implements GitRefsSubProvider {

package/src/utils/date.ts

@@ -80,6 +80,8 @@ export function createFromDateDelta(
 
 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`
+	if (!Number.isFinite(elapsed)) return '';
 
 	for (const [unit, threshold, divisor, shortUnit] of relativeUnitThresholds) {
 		const elapsedABS = Math.abs(elapsed);
@@ -134,6 +136,9 @@ export function formatDate(
 ): string {
 	format = format ?? undefined;
 
+	// Guard against invalid dates (e.g. `new Date(<unparseable>)`), since they would throw in `Intl.DateTimeFormat.format`
+	if (Number.isNaN(typeof date === 'number' ? date : date.getTime())) return '';
+
 	const key = `${locale ?? ''}:${format}`;
 
 	let formatter = dateTimeFormatCache.get(key);

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 {
-			// eslint-disable-next-line @typescript-eslint/no-this-alias
+			// oxlint-disable-next-line @typescript-eslint/no-this-alias
 			lastThis = this;
 			lastArgs = args;
 		}

package/src/utils/iterable.ts

@@ -48,6 +48,7 @@ class ChunkByStringLengthIterator implements IterableIterator<string[]> {
 	constructor(
 		private readonly source: string[],
 		private readonly maxLength: number,
+		private readonly overheadPerItem: number = 0,
 	) {}
 
 	next(): IteratorResult<string[]> {
@@ -61,7 +62,7 @@ class ChunkByStringLengthIterator implements IterableIterator<string[]> {
 
 		while (this.index < this.source.length) {
 			const item = this.source[this.index];
-			const length = chunkLength + item.length;
+			const length = chunkLength + item.length + this.overheadPerItem;
 
 			if (length > this.maxLength && chunk.length > 0) {
 				break;
@@ -80,8 +81,18 @@ class ChunkByStringLengthIterator implements IterableIterator<string[]> {
 	}
 }
 
-export function chunkByStringLength(source: string[], maxLength: number): Iterable<string[]> {
-	return new ChunkByStringLengthIterator(source, maxLength);
+/**
+ * Chunks strings so each chunk's total serialized length stays within `maxLength`.
+ * `overheadPerItem` adds a fixed per-item cost to the running total — use it when the strings will
+ * be joined with a separator or otherwise expanded per item (e.g. CLI argv: one separator + quoting
+ * per argument), so the assembled result can't exceed the limit even with many short items.
+ */
+export function chunkByStringLength(
+	source: string[],
+	maxLength: number,
+	overheadPerItem: number = 0,
+): Iterable<string[]> {
+	return new ChunkByStringLengthIterator(source, maxLength, overheadPerItem);
 }
 
 /**

package/src/utils/object.ts

@@ -1,11 +1,62 @@
-export function areEqual(a: any, b: any): boolean {
+/**
+ * Structural deep-equality. Walks both values and short-circuits on the first difference without
+ * serializing to a string (unlike a `JSON.stringify` compare): the `a === b` fast path skips
+ * unchanged shared subtrees, and unequal values bail at the first mismatched field. Handles
+ * primitives, `null`/`undefined`, `Date` (by timestamp), arrays, and plain objects.
+ *
+ * Differs from the prior `JSON.stringify` compare in three ways — each intended or matching the old
+ * behavior:
+ * - Key-order-insensitive (the old compare was order-sensitive). Observable at one caller
+ *   (`configuration.update`, when a config value equals its schema default but with different key
+ *   order), where it harmlessly treats the value as the default rather than persisting a redundant
+ *   override.
+ * - A present-but-`undefined` key is distinct from an absent key (the old compare dropped
+ *   `undefined` keys).
+ * - `Map`/`Set`/`RegExp` and other exotic objects are NOT deep-compared — they reduce to their
+ *   own-enumerable keys (so two are effectively always-equal), same as the old stringify behavior.
+ *   No caller compares those.
+ *
+ * Assumes acyclic input — it recurses without a cycle guard (a self-referential value would
+ * overflow the stack). Every caller compares JSON-origin or same-shape data.
+ */
+export function areEqual(a: unknown, b: unknown): boolean {
 	if (a === b) return true;
 	if (a == null || b == null) return false;
 
-	const aType = typeof a;
-	if (aType === typeof b && (aType === 'string' || aType === 'number' || aType === 'boolean')) return false;
+	const type = typeof a;
+	if (type !== typeof b || type !== 'object') return false;
+
+	// Both are non-null objects from here.
+	if (a instanceof Date) return b instanceof Date && a.getTime() === b.getTime();
+	if (b instanceof Date) return false;
+
+	const aIsArray = Array.isArray(a);
+	if (aIsArray !== Array.isArray(b)) return false;
+
+	if (aIsArray) {
+		const arrA = a as unknown[];
+		const arrB = b as unknown[];
+		if (arrA.length !== arrB.length) return false;
 
-	return JSON.stringify(a) === JSON.stringify(b);
+		for (let i = 0; i < arrA.length; i++) {
+			if (!areEqual(arrA[i], arrB[i])) return false;
+		}
+		return true;
+	}
+
+	const objA = a as Record<string, unknown>;
+	const objB = b as Record<string, unknown>;
+	const keysA = Object.keys(objA);
+	if (keysA.length !== Object.keys(objB).length) return false;
+
+	// Equal key COUNT alone doesn't prove equal key SETS — without the `hasOwn` check,
+	// `{ a: 1, b: undefined }` and `{ a: 1, c: undefined }` would falsely compare equal (each
+	// missing key reads as `undefined`). The count check plus "every A-key is an own-key of B"
+	// together guarantee identical key sets.
+	for (const key of keysA) {
+		if (!Object.hasOwn(objB, key) || !areEqual(objA[key], objB[key])) return false;
+	}
+	return true;
 }
 
 type Primitive = string | number | boolean;

package/src/utils/paging.ts

@@ -26,24 +26,24 @@ export class PageableResult<T> {
 	}
 
 	async *values(): AsyncIterable<NonNullable<T>> {
-		if (this.cached != null) {
-			for (const value of this.cached.values) {
-				yield value;
-			}
+		let page = this.cached;
+		if (page == null) {
+			// No seed or cached results yet, so perform the initial fetch
+			page = await this.fetch(undefined);
+			this.cached = page;
 		}
 
-		let results = this.cached;
-		while (results == null || results.paging?.more) {
-			results = await this.fetch(results?.paging);
+		const cached = page; // memoized accumulator (the first page)
+		for (const value of cached.values) {
+			yield value;
+		}
 
-			if (this.cached == null) {
-				this.cached = results;
-			} else {
-				this.cached.values.push(...results.values);
-				this.cached.paging = results.paging;
-			}
+		while (page.paging?.more) {
+			page = await this.fetch(page.paging);
+			cached.values.push(...page.values);
+			cached.paging = page.paging;
 
-			for (const value of results.values) {
+			for (const value of page.values) {
 				yield value;
 			}
 		}

package/src/utils/promiseCache.ts

@@ -172,14 +172,18 @@ export class PromiseCache<K, V> {
 		this.controllers.set(key, cacheable);
 
 		const promise = factory(cacheable, abortAgg.signal);
-		void promise.finally(() => {
-			if (cacheable.invalidated) {
-				this.cache.delete(key);
-			}
-			abortAgg.dispose();
-			this.aborts.delete(key);
-			this.controllers.delete(key);
-		});
+		void promise
+			.finally(() => {
+				if (cacheable.invalidated) {
+					this.cache.delete(key);
+				}
+				abortAgg.dispose();
+				this.aborts.delete(key);
+				this.controllers.delete(key);
+			})
+			// Swallow the cleanup chain's rejection so it doesn't surface as an unhandled rejection
+			// separate from the caller-facing promise's own handling (e.g. on cancellation).
+			.catch(() => {});
 
 		if (options?.onError != null) {
 			// Wrap the promise to handle errors with the onError callback
@@ -393,14 +397,18 @@ export class PromiseMap<K, V> {
 
 		// Automatically remove failed promises from the cache
 		promise.catch(() => this.cache.delete(key));
-		void promise.finally(() => {
-			if (cacheable.invalidated) {
-				this.cache.delete(key);
-			}
-			aborts.dispose();
-			this.aborts.delete(key);
-			this.controllers.delete(key);
-		});
+		void promise
+			.finally(() => {
+				if (cacheable.invalidated) {
+					this.cache.delete(key);
+				}
+				aborts.dispose();
+				this.aborts.delete(key);
+				this.controllers.delete(key);
+			})
+			// Swallow the cleanup chain's rejection so it doesn't surface as an unhandled rejection
+			// separate from the caller-facing promise's own handling (e.g. on cancellation).
+			.catch(() => {});
 
 		this.cache.set(key, promise);
 

package/src/utils/string.ts

@@ -769,7 +769,7 @@ export function pluralize(
 }
 
 // Removes \ / : * ? " < > | and C0 and C1 control codes
-// eslint-disable-next-line no-control-regex
+// oxlint-disable-next-line no-control-regex
 const illegalCharsForFSRegex = /[\\/:*?"<>|\x00-\x1f\x80-\x9f]/g;
 
 export function sanitizeForFileSystem(s: string, replacement: string = '_'): string {