Reverse engineer anything with agents, from app behavior down to native binaries.
TypeScript agent-skillsai-agentsbinary-analysisclaude-codeclicodexcordisdecompilerdeveloper-toolsdshdsh-pluginghidrahopperllmmcpmodel-context-protocolreareverse-engineeringstatic-analysistouhou
fix(artifacts)!: preserve descriptor cleanup authority
morlutobe6272f26115
diff --git a/src/artifacts/ArtifactResourceScope.ts b/src/artifacts/ArtifactResourceScope.tsindex b7da3fd83..8e86e14bd 100644--- a/src/artifacts/ArtifactResourceScope.ts+++ b/src/artifacts/ArtifactResourceScope.ts@@ -1,4 +1,4 @@-import type { FileHandle } from "node:fs/promises";+import type { OwnedFileHandle } from "../filesystem/OwnedFileHandle.js";import type { ArtifactReader } from "./ArtifactReader.js";import { ArtifactReaderFailure } from "./ArtifactReader.js";@@ -14,7 +14,7 @@ export type ArtifactResourceOwner =| {readonly kind: "file-handle";readonly resource: string;- readonly handle: FileHandle;+ readonly handle: OwnedFileHandle;}| {readonly kind: "output-tree";diff --git a/src/artifacts/OwnedFileHandle.test.ts b/src/artifacts/OwnedFileHandle.test.tsnew file mode 100644index 000000000..aeb6649d5--- /dev/null+++ b/src/artifacts/OwnedFileHandle.test.ts@@ -0,0 +1,57 @@+import { expect, it, vi } from "vitest";++import { OwnedFileHandle } from "../filesystem/OwnedFileHandle.js";++it("shares one in-flight successful close between concurrent owners", async () => {+ let resolveClose: (() => void) | undefined;+ const file = {+ fd: 17,+ close: vi.fn(+ () =>+ new Promise<void>((resolve) => {+ file.fd = -1;+ resolveClose = resolve;+ }),+ ),+ };+ const owner = new OwnedFileHandle(file);++ const first = owner.close();+ const second = owner.close();+ await Promise.resolve();+ expect(file.close).toHaveBeenCalledTimes(1);+ resolveClose?.();++ await expect(Promise.all([first, second])).resolves.toEqual([+ undefined,+ undefined,+ ]);+ await expect(owner.close()).resolves.toBeUndefined();+ expect(file.close).toHaveBeenCalledTimes(1);+});++it("shares one in-flight failed close and keeps its unconfirmed result sticky", async () => {+ const failure = new Error("native close failed");+ let rejectClose: (() => void) | undefined;+ const file = {+ fd: 17,+ close: vi.fn(+ () =>+ new Promise<void>((_resolve, reject) => {+ file.fd = -1;+ rejectClose = () => reject(failure);+ }),+ ),+ };+ const owner = new OwnedFileHandle(file);++ const first = owner.close();+ const second = owner.close();+ await Promise.resolve();+ expect(file.close).toHaveBeenCalledTimes(1);+ rejectClose?.();++ await expect(Promise.all([first, second])).rejects.toBe(failure);+ await expect(owner.close()).rejects.toBe(failure);+ expect(file.close).toHaveBeenCalledTimes(1);+});diff --git a/src/artifacts/RegularFileAdmission.test.ts b/src/artifacts/RegularFileAdmission.test.tsnew file mode 100644index 000000000..818e75ef1--- /dev/null+++ b/src/artifacts/RegularFileAdmission.test.ts@@ -0,0 +1,68 @@+import type { Stats } from "node:fs";+import type { FileHandle } from "node:fs/promises";+import { afterEach, expect, it, vi } from "vitest";++import {+ NonRegularFileReadError,+ openRegularFile,+ RegularFileAdmissionFailure,+} from "../filesystem/RegularFile.js";++const { mockOpen } = vi.hoisted(() => ({ mockOpen: vi.fn() }));++vi.mock("node:fs/promises", async (importOriginal) => ({+ ...(await importOriginal<typeof import("node:fs/promises")>()),+ open: mockOpen,+}));++afterEach(() => mockOpen.mockReset());++it.each(["cancellation after open", "non-regular metadata", "stat failure"])(+ "retains the exact owner when close fails after %s",+ async (failureCase) => {+ const closeFailure = new Error("native close failed");+ const statFailure = new Error("descriptor stat failed");+ const cancellation = new Error("cancelled after open");+ const controller = new AbortController();+ const file = {+ fd: 17,+ stat: vi.fn(async () => {+ if (failureCase === "cancellation after open") {+ controller.abort(cancellation);+ return { isFile: () => true } as Stats;+ }+ if (failureCase === "non-regular metadata")+ return {+ isFile: () => false,+ isDirectory: () => false,+ } as Stats;+ throw statFailure;+ }),+ close: vi.fn(async () => {+ file.fd = -1;+ throw closeFailure;+ }),+ };+ mockOpen.mockResolvedValue(file as unknown as FileHandle);++ const cause = await openRegularFile("/selected/input", {+ symlinks: "reject",+ signal: controller.signal,+ }).catch((failure: unknown) => failure);++ expect(cause).toBeInstanceOf(RegularFileAdmissionFailure);+ if (!(cause instanceof RegularFileAdmissionFailure))+ throw new Error("Expected an admission failure that retains its owner");+ expect(cause.owner.handle).toBe(file);+ expect(cause.cleanupCause).toBe(closeFailure);+ expect(file.close).toHaveBeenCalledTimes(1);+ await expect(cause.owner.close()).rejects.toBe(closeFailure);+ expect(file.close).toHaveBeenCalledTimes(1);++ if (failureCase === "non-regular metadata")+ expect(cause.cause).toBeInstanceOf(NonRegularFileReadError);+ else if (failureCase === "stat failure")+ expect(cause.cause).toBe(statFailure);+ else expect(cause.cause).toBe(cancellation);+ },+);diff --git a/src/artifacts/inventory/classify.ts b/src/artifacts/inventory/classify.tsindex 7932c519e..6534fcfdf 100644--- a/src/artifacts/inventory/classify.ts+++ b/src/artifacts/inventory/classify.ts@@ -1,11 +1,8 @@-import {- NonRegularFileReadError,- openRegularFile,- sameRegularFileState,-} from "../../filesystem/RegularFile.js";+import { sameRegularFileState } from "../../filesystem/RegularFile.js";import type { FileHandle } from "node:fs/promises";import type { Stats } from "node:fs";import type { StableRegularFileDescriptor } from "../../filesystem/RegularFile.js";+import type { OwnedFileHandle } from "../../filesystem/OwnedFileHandle.js";import { classifyArtifactContent } from "./ArtifactGraphConstruction.js";import { ARTIFACT_CLASSIFICATION_PREFIX_BYTES } from "../ArtifactHash.js";@@ -17,7 +14,10 @@ import {import { ArtifactReaderFailure } from "../ArtifactReader.js";import { type ArtifactResourceOwner } from "../ArtifactResourceScope.js";import type { HashResult } from "../ArtifactHash.js";-import { hashStableRootArtifactHandle } from "./hashStableRootArtifact.js";+import {+ hashStableRootArtifactHandle,+ openRootArtifact,+} from "./hashStableRootArtifact.js";import type { ArtifactInventoryOptions } from "./types.js";interface RootClassification {@@ -26,9 +26,14 @@ interface RootClassification {}type RootInventoryClassification = RootClassification & {- readonly rootSource: StableRegularFileDescriptor | undefined;+ readonly rootSource: RootInventorySource | undefined;};+/** The admitted descriptor and the single owner that can confirm its close. */+export interface RootInventorySource extends StableRegularFileDescriptor {+ readonly owner: OwnedFileHandle;+}+/** Classify and hash one file root through the same stable open descriptor. */export const classifyAndHashRoot = async (path: string,@@ -47,7 +52,7 @@ export const classifyAndHashRoot = async (if (rootSource !== undefined) {const owner: ArtifactResourceOwner = {kind: "file-handle",- handle: rootSource.handle,+ handle: rootSource.owner,resource: `root artifact descriptor for ${path}`,};const cleanupAttempt = await options.resourceScope.release(owner);@@ -73,10 +78,15 @@ export const classifyAndHashRootForInventory = async (): Promise<RootInventoryClassification> => {if (directory)return { format: "directory", digest: null, rootSource: undefined };- const handle = await openRootFile(path, options.signal);+ const ownedHandle = await openRootArtifact(+ path,+ options.resourceScope,+ options.signal,+ );+ const handle = ownedHandle.handle;const owner: ArtifactResourceOwner = {kind: "file-handle",- handle,+ handle: ownedHandle,resource: `root artifact descriptor for ${path}`,};let outcome:@@ -105,7 +115,9 @@ export const classifyAndHashRootForInventory = async (value: {format,digest,- rootSource: retainSource ? { handle, initial } : undefined,+ rootSource: retainSource+ ? { handle, initial, owner: ownedHandle }+ : undefined,},};} catch (cause: unknown) {@@ -133,23 +145,6 @@ const isZipFormat = (format: ArtifactOccurrence["artifact_format"]): boolean =>format === "msix" ||format === "appx";-const openRootFile = async (- path: string,- signal?: AbortSignal,-): Promise<FileHandle> => {- try {- return await openRegularFile(path, { symlinks: "reject", signal });- } catch (cause: unknown) {- if (cause instanceof NonRegularFileReadError)- throw new ArtifactReaderFailure(- "format",- `Artifact root is not a regular file: ${path}`,- { cause },- );- throw cause;- }-};-const classifyRootFormat = async (path: string,handle: FileHandle,diff --git a/src/artifacts/inventory/hashStableRootArtifact.ts b/src/artifacts/inventory/hashStableRootArtifact.tsindex cd3cc302c..40a8a5fd6 100644--- a/src/artifacts/inventory/hashStableRootArtifact.ts+++ b/src/artifacts/inventory/hashStableRootArtifact.ts@@ -1,10 +1,13 @@import { lstat } from "node:fs/promises";import type { Stats } from "node:fs";import type { FileHandle } from "node:fs/promises";+import { readFileHandleChunks } from "../../filesystem/readFileHandleChunks.js";+import { OwnedFileHandle } from "../../filesystem/OwnedFileHandle.js";import { ArtifactReaderFailure } from "../ArtifactReader.js";import {NonRegularFileReadError,+ RegularFileAdmissionFailure,openRegularFile,sameRegularFileState,} from "../../filesystem/RegularFile.js";@@ -13,33 +16,79 @@ import {hashReadable,type HashResult,} from "../ArtifactHash.js";+import type { ArtifactResourceScope } from "../ArtifactResourceScope.js";-/** Hash one stable regular root file from the same descriptor that was checked. */-export const hashStableRootArtifact = async (+/** Admit a root descriptor without losing ownership when validation cleanup fails. */+export const openRootArtifact = async (path: string,+ resourceScope: ArtifactResourceScope,signal?: AbortSignal,-): Promise<HashResult> => {- let handle: FileHandle;+): Promise<OwnedFileHandle> => {try {- handle = await openRegularFile(path, {- symlinks: "reject",- signal,- });+ return new OwnedFileHandle(+ await openRegularFile(path, { symlinks: "reject", signal }),+ );} catch (cause: unknown) {- if (cause instanceof NonRegularFileReadError)- throw new ArtifactReaderFailure(- "format",- `Artifact root is not a regular file: ${path}`,- { cause },- );- throw cause;+ const primary =+ cause instanceof RegularFileAdmissionFailure ? cause.cause : cause;+ const failure =+ primary instanceof NonRegularFileReadError+ ? new ArtifactReaderFailure(+ "format",+ `Artifact root is not a regular file: ${path}`,+ { cause: primary },+ )+ : primary;+ if (cause instanceof RegularFileAdmissionFailure) {+ const resource = `root artifact descriptor for ${path}`;+ const cleanup = await resourceScope.release({+ kind: "file-handle",+ resource,+ handle: cause.owner,+ });+ if (cleanup.kind === "failed")+ throw ArtifactReaderFailure.withCleanup(+ failure,+ ArtifactReaderFailure.cleanupObservation(cleanup.cause, resource),+ );+ }+ throw failure;}+};++/** Hash one stable regular root file from the same descriptor that was checked. */+export const hashStableRootArtifact = async (+ path: string,+ resourceScope: ArtifactResourceScope,+ signal?: AbortSignal,+): Promise<HashResult> => {+ const owner = await openRootArtifact(path, resourceScope, signal);+ const handle = owner.handle;+ let outcome:+ | { readonly kind: "completed"; readonly value: HashResult }+ | { readonly kind: "failed"; readonly cause: unknown };try {const initial = await handle.stat();- return await hashStableRootArtifactHandle(path, handle, initial, signal);- } finally {- await handle.close();+ outcome = {+ kind: "completed",+ value: await hashStableRootArtifactHandle(path, handle, initial, signal),+ };+ } catch (cause: unknown) {+ outcome = { kind: "failed", cause };}+ const resource = `root artifact descriptor for ${path}`;+ const cleanup = await resourceScope.release({+ kind: "file-handle",+ resource,+ handle: owner,+ });+ if (cleanup.kind === "failed")+ throw ArtifactReaderFailure.withCleanup(+ outcome.kind === "failed" ? outcome.cause : cleanup.cause,+ ArtifactReaderFailure.cleanupObservation(cleanup.cause, resource),+ );+ if (outcome.kind === "failed") throw outcome.cause;+ return outcome.value;};/** Hash and revalidate the same open descriptor used for root classification. */@@ -52,7 +101,7 @@ export const hashStableRootArtifactHandle = async (const digest = await hashReadable(// Read at most the admitted extent plus one byte to detect growth without// following an actively appended file indefinitely.- handle.createReadStream({ autoClose: false, start: 0, end: initial.size }),+ readFileHandleChunks(handle, { start: 0, end: initial.size }),signal,);abortIfNeeded(signal);diff --git a/src/artifacts/inventory/scanCanonical.ts b/src/artifacts/inventory/scanCanonical.tsindex 2d36bcd74..098577311 100644--- a/src/artifacts/inventory/scanCanonical.ts+++ b/src/artifacts/inventory/scanCanonical.ts@@ -5,7 +5,7 @@ import { AsarArtifactReader } from "../AsarArtifactReader.js";import { lstat } from "node:fs/promises";import type { Stats } from "node:fs";-import type { StableRegularFileDescriptor } from "../../filesystem/RegularFile.js";+import type { RootInventorySource } from "./classify.js";import {ArtifactReaderFailure,@@ -107,6 +107,7 @@ export const scanCanonicalArtifactInventoryInScope = async (rootFormat,rootDigest,rootSource,+ resourceScope: options.resourceScope,reader,signal: options.signal,nodes,@@ -146,7 +147,7 @@ const cleanupInventoryOwners = async ({}: {readonly path: string;readonly options: ArtifactInventoryOptions;- readonly rootSource: StableRegularFileDescriptor | undefined;+ readonly rootSource: RootInventorySource | undefined;readonly ownedReaders: readonly ArtifactReader[];readonly outcome: InventoryScanOutcome;}): Promise<ArtifactReaderFailure | undefined> => {@@ -161,7 +162,7 @@ const cleanupInventoryOwners = async ({if (rootSource !== undefined)owners.push({kind: "file-handle",- handle: rootSource.handle,+ handle: rootSource.owner,resource: `root artifact descriptor for ${path}`,});for (const owner of owners) {@@ -182,11 +183,12 @@ const cleanupInventoryOwners = async ({};interface SnapshotBuildInput {+ readonly resourceScope: ArtifactInventoryOptions["resourceScope"];readonly path: string;readonly metadata: Stats;readonly rootFormat: ArtifactOccurrence["artifact_format"];readonly rootDigest: HashResult | null;- readonly rootSource: StableRegularFileDescriptor | undefined;+ readonly rootSource: RootInventorySource | undefined;readonly reader: ArtifactReader | undefined;readonly signal: AbortSignal | undefined;readonly nodes: Map<string, ArtifactNode>;@@ -243,7 +245,13 @@ const buildInventorySnapshot = async (ordinal,}));- await verifyRootDigest(path, rootDigest, rootSource, signal);+ await verifyRootDigest(+ path,+ rootDigest,+ rootSource,+ input.resourceScope,+ signal,+ );const graphSha256 = artifactGraphDigest({nodes: orderedNodes,@@ -318,13 +326,14 @@ const buildIntegrityContradictions = (const verifyRootDigest = async (path: string,rootDigest: HashResult | null,- rootSource: StableRegularFileDescriptor | undefined,+ rootSource: RootInventorySource | undefined,+ resourceScope: ArtifactInventoryOptions["resourceScope"],signal: AbortSignal | undefined,): Promise<void> => {if (rootDigest === null) return;const verified =rootSource === undefined- ? await hashStableRootArtifact(path, signal)+ ? await hashStableRootArtifact(path, resourceScope, signal): await hashStableRootArtifactHandle(path,rootSource.handle,diff --git a/src/filesystem/OwnedFileHandle.ts b/src/filesystem/OwnedFileHandle.tsnew file mode 100644index 000000000..8c1b7ede4--- /dev/null+++ b/src/filesystem/OwnedFileHandle.ts@@ -0,0 +1,45 @@+import type { FileHandle } from "node:fs/promises";++type CloseState =+ | { readonly kind: "open" }+ | { readonly kind: "closing"; readonly attempt: Promise<void> }+ | { readonly kind: "closed" }+ | { readonly kind: "failed"; readonly cause: unknown };++/** One file handle whose close result must remain truthful across retries. */+export class OwnedFileHandle<+ Handle extends Pick<FileHandle, "fd" | "close"> = FileHandle,+> {+ #state: CloseState = { kind: "open" };++ constructor(readonly handle: Handle) {}++ /** Close the owned handle, retaining an unconfirmed close as a sticky failure. */+ close(): Promise<void> {+ if (this.#state.kind === "closed") return Promise.resolve();+ if (this.#state.kind === "closing") return this.#state.attempt;+ if (this.#state.kind === "failed") return Promise.reject(this.#state.cause);+ if (this.handle.fd < 0) {+ const cause = new Error(+ "File handle was invalidated before this owner confirmed its close",+ );+ this.#state = { kind: "failed", cause };+ return Promise.reject(cause);+ }++ const attempt = Promise.resolve().then(() => this.#attemptClose());+ this.#state = { kind: "closing", attempt };+ return attempt;+ }++ async #attemptClose(): Promise<void> {+ try {+ await this.handle.close();+ this.#state = { kind: "closed" };+ } catch (cause: unknown) {+ this.#state =+ this.handle.fd < 0 ? { kind: "failed", cause } : { kind: "open" };+ throw cause;+ }+ }+}diff --git a/src/filesystem/RegularFile.ts b/src/filesystem/RegularFile.tsindex 69edcad31..a5c2391cf 100644--- a/src/filesystem/RegularFile.ts+++ b/src/filesystem/RegularFile.ts@@ -2,6 +2,8 @@ import { constants } from "node:fs";import type { BigIntStats, Stats } from "node:fs";import { open, type FileHandle } from "node:fs/promises";+import { OwnedFileHandle } from "./OwnedFileHandle.js";+/** Identifies a selected path that cannot be read as one regular file. */export class NonRegularFileReadError extends Error {readonly code: "EISDIR" | "ENOTFILE";@@ -16,6 +18,24 @@ export class NonRegularFileReadError extends Error {}}+/** Admission failed and the opened descriptor could not be confirmed closed. */+export class RegularFileAdmissionFailure extends Error {+ override readonly cause: unknown;++ constructor(+ readonly path: string,+ admissionCause: unknown,+ readonly cleanupCause: unknown,+ readonly owner: OwnedFileHandle,+ ) {+ super(+ `Selected input failed admission and its descriptor close failed: ${path}`,+ );+ this.name = "RegularFileAdmissionFailure";+ this.cause = admissionCause;+ }+}+/** A regular input no longer matches the extent or identity admitted for reading. */export class RegularFileChangedError extends Error {readonly code = "ESTALE";@@ -47,6 +67,7 @@ export const openRegularFile = async ((constants.O_NOCTTY ?? 0) |(options.symlinks === "reject" ? (constants.O_NOFOLLOW ?? 0) : 0),);+ const owner = new OwnedFileHandle(handle);try {options.signal?.throwIfAborted();const metadata = await handle.stat();@@ -55,7 +76,11 @@ export const openRegularFile = async (throw new NonRegularFileReadError(path, metadata.isDirectory());return handle;} catch (cause: unknown) {- await handle.close().catch(() => undefined);+ try {+ await owner.close();+ } catch (cleanupCause: unknown) {+ throw new RegularFileAdmissionFailure(path, cause, cleanupCause, owner);+ }throw cause;}};diff --git a/src/filesystem/readFileHandleChunks.ts b/src/filesystem/readFileHandleChunks.tsnew file mode 100644index 000000000..f0e205891--- /dev/null+++ b/src/filesystem/readFileHandleChunks.ts@@ -0,0 +1,46 @@+import type { FileHandle } from "node:fs/promises";+import { Readable } from "node:stream";++/** Stream positional reads while leaving descriptor cleanup to its owner. */+export const readFileHandleChunks = (+ handle: Pick<FileHandle, "read">,+ options: {+ readonly start?: number;+ readonly end?: number;+ readonly signal?: AbortSignal | undefined;+ } = {},+): Readable => {+ const start = options.start ?? 0;+ const end = options.end ?? Infinity;+ if (+ !Number.isSafeInteger(start) ||+ start < 0 ||+ (end !== Infinity && (!Number.isSafeInteger(end) || end < start))+ )+ throw new RangeError("Invalid file read range");+ return Readable.from(+ (async function* () {+ let position = start;+ while (position <= end) {+ options.signal?.throwIfAborted();+ const chunk = Buffer.allocUnsafe(+ Math.min(64 * 1024, end - position + 1),+ );+ const { bytesRead } = await handle.read(+ chunk,+ 0,+ chunk.length,+ position,+ );+ options.signal?.throwIfAborted();+ if (bytesRead === 0) return;+ position += bytesRead;+ yield chunk.subarray(0, bytesRead);+ }+ })(),+ {+ objectMode: false,+ ...(options.signal === undefined ? {} : { signal: options.signal }),+ },+ );+};diff --git a/tests/boundary/filesystem/artifactInventoryDescriptorCleanup.test.ts b/tests/boundary/filesystem/artifactInventoryDescriptorCleanup.test.tsnew file mode 100644index 000000000..d89714ceb--- /dev/null+++ b/tests/boundary/filesystem/artifactInventoryDescriptorCleanup.test.ts@@ -0,0 +1,92 @@+import type { FileHandle } from "node:fs/promises";+import { writeFile } from "node:fs/promises";+import { join } from "node:path";+import { expect, it, onTestFinished, vi } from "vitest";++import { ArtifactProvider } from "../../../src/artifacts/ArtifactProvider.js";+import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";++const injected = vi.hoisted(() => ({+ opened: undefined as+ | ((path: unknown, handle: FileHandle) => void)+ | undefined,+}));++vi.mock("node:fs/promises", async (importOriginal) => {+ const actual = await importOriginal<typeof import("node:fs/promises")>();+ return {+ ...actual,+ open: async (...args: Parameters<typeof actual.open>) => {+ const handle = await actual.open(...args);+ injected.opened?.(args[0], handle);+ return handle;+ },+ };+});++it.each([false, true])(+ "preserves root admission failure and close authority (invalidated=%s)",+ async (invalidated) => {+ const root = await createTestTempDirectory("rea-root-admission-cleanup-");+ const path = join(root, "payload.bin");+ await writeFile(path, "selected bytes");+ const client = new ArtifactProvider({}).createClient({+ path,+ sourcePath: path,+ sha256: "0".repeat(64),+ kind: "artifact",+ format: "javascript",+ });+ let descriptor: FileHandle | undefined;+ let closeAttempts = 0;+ let blocked = true;+ injected.opened = (openedPath, handle) => {+ if (openedPath !== path || descriptor !== undefined) return;+ descriptor = handle;+ const close = handle.close.bind(handle);+ vi.spyOn(handle, "stat").mockRejectedValueOnce(+ Object.assign(new Error("primary admission stat failure"), {+ code: "EIO",+ errno: -5,+ syscall: "fstat",+ }),+ );+ vi.spyOn(handle, "close").mockImplementation(async () => {+ closeAttempts += 1;+ if (invalidated) await close();+ if (blocked) throw new Error("descriptor cleanup outcome unavailable");+ await close();+ });+ };+ onTestFinished(async () => {+ injected.opened = undefined;+ blocked = false;+ await client.close();+ vi.restoreAllMocks();+ });++ const inventory = await client.execute("inventory_artifact", {});+ expect(inventory).toMatchObject({+ ok: false,+ error: {+ reason: "io",+ detail: expect.stringContaining("primary admission stat failure"),+ cleanup: {+ resources: [expect.stringContaining(path)],+ reason: "descriptor cleanup outcome unavailable",+ },+ },+ });+ expect(descriptor).toBeDefined();+ expect((await client.close()).ok).toBe(false);+ const attemptsBeforeRecovery = closeAttempts;+ blocked = false;+ const recovery = await client.close();+ expect(recovery.ok).toBe(!invalidated);+ expect(closeAttempts).toBe(+ invalidated ? attemptsBeforeRecovery : attemptsBeforeRecovery + 1,+ );+ expect(descriptor?.fd).toBe(-1);+ if (invalidated) expect(closeAttempts).toBe(1);+ },+);