rea-agents 6.5.0 → 6.7.0

package/dist/cli-runtime/{ProviderDeadline-8m2pFRDc.js → ProviderDeadline-rSuH4Pm8.js}

@@ -1,5 +1,31 @@
 import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
 
+//#region dist/process/AbortablePromise.js
+var ABORTED, waitForAbortable;
+function init_AbortablePromise() {
+	return (init_AbortablePromise = __esmMin((() => {
+		ABORTED = Symbol("aborted");
+		waitForAbortable = async (pending, signal) => {
+			if (signal === undefined) return pending;
+			let onAbort;
+			const cancelled = new Promise((resolve) => {
+				if (signal.aborted) {
+					resolve(ABORTED);
+					return;
+				}
+				onAbort = () => resolve(ABORTED);
+				signal.addEventListener("abort", onAbort, { once: true });
+			});
+			try {
+				return await Promise.race([cancelled, pending]);
+			} finally {
+				if (onAbort !== undefined) signal.removeEventListener("abort", onAbort);
+			}
+		};
+	})))();
+}
+
+//#endregion
 //#region dist/process/ProviderDeadline.js
 var waitForAbortableDelay, ProviderStartupDeadline;
 function init_ProviderDeadline() {
@@ -119,4 +145,4 @@ function init_ProviderDeadline() {
 }
 
 //#endregion
-export { ProviderStartupDeadline, init_ProviderDeadline, waitForAbortableDelay };
+export { ABORTED, ProviderStartupDeadline, init_AbortablePromise, init_ProviderDeadline, waitForAbortable, waitForAbortableDelay };

package/dist/cli-runtime/ProviderOperationExecution-CmU-XrQr.js

@@ -0,0 +1,38 @@
+import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
+import { err, init_result, ok } from "./reconstructionObligationLedgerSchemas-Bi6sect1.js";
+import { AnalysisCancelledError, AnalysisInputError, init_analysisErrorCore } from "./errorSchemas-Ixz_q7qt.js";
+import { createAnalysisExecutionEvidence, init_AnalysisProvider } from "./AnalysisProvider-BGrYaMVo.js";
+import { z } from "zod";
+
+//#region dist/application/ProviderOperationExecution.js
+var executeProviderOperation, completeProviderEvidence;
+function init_ProviderOperationExecution() {
+	return (init_ProviderOperationExecution = __esmMin((() => {
+		init_analysisErrorCore();
+		init_result();
+		init_AnalysisProvider();
+		executeProviderOperation = async (operation, input, options, schema, provider, confidence) => {
+			if (options?.signal?.aborted) return err(new AnalysisCancelledError(operation, { cause: options.signal.reason }));
+			const request = schema.safeParse({
+				operation,
+				input
+			});
+			if (!request.success) return err(new AnalysisInputError(operation, { cause: request.error }));
+			const executed = await provider.execute(request.data, options);
+			if (!executed.ok) return executed;
+			const evidence = createAnalysisExecutionEvidence(operation, request.data.input, executed.value, confidence);
+			return completeProviderEvidence(evidence, options?.signal);
+		};
+		completeProviderEvidence = (evidence, signal, capturedOutput) => {
+			if (signal?.aborted) return err(new AnalysisCancelledError(evidence.operation, {
+				cause: signal.reason,
+				partialObservation: evidence,
+				...capturedOutput === undefined ? {} : { capturedOutput }
+			}));
+			return ok(evidence);
+		};
+	})))();
+}
+
+//#endregion
+export { completeProviderEvidence, executeProviderOperation, init_ProviderOperationExecution };

package/dist/cli-runtime/{snapshotEnvironment-D_tWyOub.js → ProviderProcess-D87A7ctp.js}

@@ -1,139 +1,11 @@
 import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
-import { init_ProcessOwnershipObservation, prepareProcessOwnershipInspection, systemProcessOwnershipHost } from "./ProcessOwnership-DXC5-UWt.js";
-import { createRequire } from "node:module";
+import { init_ProcessOwnershipObservation, prepareProcessOwnershipInspection, systemProcessOwnershipHost } from "./ProcessOwnershipObservation-C006iCtZ.js";
+import { init_WindowsNativeLoader, requireWindowsNativeAuthority, windowsHandleSchema } from "./WindowsNativeLoader-BqyZO0ZD.js";
 import { z } from "zod";
-import { createHash } from "node:crypto";
-import { readFileSync } from "node:fs";
 import { spawn } from "node:child_process";
 import { EventEmitter } from "node:events";
 import { PassThrough, Writable } from "node:stream";
-import { fileURLToPath } from "node:url";
-import { PACKAGE_METADATA } from "../generatedPackageMetadata.js";
 
-//#region dist/windows/WindowsNativeLoader.js
-var windowsHandleSchema, windowsFileIdentitySchema, windowsNativeManifestSchema, inspectionSchema, bindingSchema, loadWindowsNativeAuthority, assertWindowsX64Artifact, cached, systemWindowsNativeAuthority, requireWindowsNativeAuthority;
-function init_WindowsNativeLoader() {
-	return (init_WindowsNativeLoader = __esmMin((() => {
-		windowsHandleSchema = z.custom((value) => typeof value === "object" && value !== null && !Array.isArray(value));
-		windowsFileIdentitySchema = z.strictObject({
-			requestedPath: z.string(),
-			finalPath: z.string(),
-			filesystem: z.literal("NTFS"),
-			volumeSerial: z.string().regex(/^[a-f0-9]{16}$/u),
-			fileId: z.string().regex(/^[a-f0-9]{32}$/u),
-			size: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
-			directory: z.boolean()
-		});
-		windowsNativeManifestSchema = z.strictObject({
-			packageVersion: z.string(),
-			platform: z.literal("win32"),
-			architecture: z.literal("x64"),
-			abiVersion: z.literal(1),
-			nodeApiVersion: z.literal(8),
-			artifact: z.literal("rea-windows-x64.node"),
-			artifactSha256: z.string().regex(/^[a-f0-9]{64}$/u)
-		});
-		inspectionSchema = z.strictObject({
-			abiVersion: z.literal(1),
-			nodeApiVersion: z.literal(8),
-			architecture: z.literal("x64"),
-			filesystem: windowsFileIdentitySchema,
-			privateDacl: z.literal(true),
-			privateBridgeDescriptorAccess: z.literal(true),
-			atomicJobAssignment: z.literal(true),
-			killOnOwnerClose: z.literal(true),
-			protocolStdin: z.boolean().optional(),
-			/** Absent from artifacts built before owned Job Object commit limits. */
-			jobMemoryLimit: z.literal(true).optional()
-		});
-		bindingSchema = z.strictObject({ call: z.custom((value) => typeof value === "function") });
-		loadWindowsNativeAuthority = (host) => {
-			if (host.platform !== "win32" || host.architecture !== "x64") return {
-				available: false,
-				failureStage: "host",
-				reason: "REA Windows native controls require a Windows x64 host."
-			};
-			const nodeApiVersion = Number(host.nodeApiVersion);
-			if (!Number.isSafeInteger(nodeApiVersion) || nodeApiVersion < 8) return {
-				available: false,
-				failureStage: "host",
-				reason: "REA Windows native controls require Node-API 8 or newer."
-			};
-			try {
-				const manifest = windowsNativeManifestSchema.parse(host.readManifest());
-				if (manifest.packageVersion !== host.packageVersion) throw new Error("Windows native artifact belongs to another REA version");
-				const artifact = host.readArtifact();
-				if (createHash("sha256").update(artifact).digest("hex") !== manifest.artifactSha256) throw new Error("Windows native artifact SHA-256 does not match package metadata");
-				assertWindowsX64Artifact(artifact);
-				const binding = bindingSchema.parse(host.loadArtifact());
-				let observed;
-				try {
-					observed = binding.call("inspect", []);
-				} catch (cause) {
-					return {
-						available: false,
-						failureStage: "self-test",
-						retryable: true,
-						reason: `REA Windows native self-test failed: ${cause instanceof Error ? cause.message : String(cause)}`
-					};
-				}
-				const parsed = inspectionSchema.safeParse(observed);
-				if (!parsed.success) return {
-					available: false,
-					failureStage: "inspection",
-					reason: `REA Windows native inspection is invalid: ${parsed.error.message}`
-				};
-				const inspection = parsed.data;
-				return {
-					available: true,
-					authority: {
-						call: binding.call,
-						inspection
-					}
-				};
-			} catch (cause) {
-				return {
-					available: false,
-					failureStage: "artifact",
-					reason: `REA Windows native controls are unavailable: ${cause instanceof Error ? cause.message : String(cause)}`
-				};
-			}
-		};
-		assertWindowsX64Artifact = (bytes) => {
-			if (bytes.length < 64 || bytes.toString("latin1", 0, 2) !== "MZ") throw new Error("Windows native artifact is not a PE image");
-			const offset = bytes.readUInt32LE(60);
-			if (offset > bytes.length - 26 || bytes.toString("latin1", offset, offset + 4) !== "PE\0\0" || bytes.readUInt16LE(offset + 4) !== 34404 || bytes.readUInt16LE(offset + 24) !== 523) throw new Error("Windows native artifact is not a Windows x64 PE32+ image");
-		};
-		;
-		systemWindowsNativeAuthority = () => {
-			if (cached?.available === false && cached.retryable === true) cached = undefined;
-			cached ??= loadWindowsNativeAuthority({
-				platform: process.platform,
-				architecture: process.arch,
-				nodeApiVersion: process.versions.napi,
-				packageVersion: PACKAGE_METADATA.version,
-				readManifest: () => {
-					const encoded = readFileSync(new URL("../../native/windows/build/manifest.json", new URL("../windows/WindowsNativeLoader.js", import.meta.url).href), "utf8");
-					const value = JSON.parse(encoded);
-					return value;
-				},
-				readArtifact: () => readFileSync(new URL("../../native/windows/build/rea-windows-x64.node", new URL("../windows/WindowsNativeLoader.js", import.meta.url).href)),
-				loadArtifact: () => {
-					const value = createRequire(new URL("../windows/WindowsNativeLoader.js", import.meta.url).href)(fileURLToPath(new URL("../../native/windows/build/rea-windows-x64.node", new URL("../windows/WindowsNativeLoader.js", import.meta.url).href)));
-					return value;
-				}
-			});
-			return cached;
-		};
-		requireWindowsNativeAuthority = () => {
-			const loaded = systemWindowsNativeAuthority();
-			if (!loaded.available) throw new Error(loaded.reason);
-			return loaded.authority;
-		};
-	})))();
-}
-
-//#endregion
 //#region dist/windows/WindowsOwnedProcess.js
 var launchSchema, pollSchema, limitedPollSchema, quoteWindowsProcessArgument, WindowsOwnedProcess;
 function init_WindowsOwnedProcess() {
@@ -395,13 +267,16 @@ function init_WindowsOwnedProcess() {
 
 //#endregion
 //#region dist/process/ProviderProcess.js
-var DEFAULT_TERMINATION_GRACE_MS, DEFAULT_KILL_GRACE_MS, spawnOwnedProviderProcess, ProviderProcessSupervisor, ProcessOutputCapture, deferred, waitForSpawn, waitForProcessEvent;
+var DEFAULT_TERMINATION_GRACE_MS, DEFAULT_KILL_GRACE_MS, OUTPUT_CLOSE_GRACE_MS, MAX_LATE_OUTPUT_BYTES, outputCheckpoints, spawnOwnedProviderProcess, ProviderProcessSupervisor, ProcessOutputCapture, deferred, waitForSpawn, waitForProcessEvent;
 function init_ProviderProcess() {
 	return (init_ProviderProcess = __esmMin((() => {
 		init_WindowsOwnedProcess();
 		init_ProcessOwnershipObservation();
 		DEFAULT_TERMINATION_GRACE_MS = 250;
 		DEFAULT_KILL_GRACE_MS = 1e3;
+		OUTPUT_CLOSE_GRACE_MS = 1e3;
+		MAX_LATE_OUTPUT_BYTES = 64 * 1024;
+		outputCheckpoints = new WeakMap();
 		spawnOwnedProviderProcess = async (options) => {
 			options.signal?.throwIfAborted();
 			await prepareProcessOwnershipInspection(options.signal);
@@ -478,6 +353,7 @@ function init_ProviderProcess() {
 			#exit = deferred();
 			#outputClose = deferred();
 			#outputClosed = false;
+			#outputIncomplete = false;
 			#stdoutObservedBytes = 0;
 			#stderrObservedBytes = 0;
 			#diagnosticTruncated = false;
@@ -504,13 +380,15 @@ function init_ProviderProcess() {
 			#onError = (cause) => {
 				this.#options.onDiagnostic?.({
 					type: "error",
-					message: cause.message
+					message: cause.message,
+					cause
 				});
 			};
 			#exitObservation;
 			#stopPromise;
 			#disposed = false;
 			#maxDiagnosticBytes;
+			#outputEpoch = 0;
 			constructor(launch, options = {}) {
 				this.launch = launch;
 				this.#options = options;
@@ -534,9 +412,13 @@ function init_ProviderProcess() {
 					signal: exit.signal
 				};
 			}
+			/** Whether the process owner acknowledged output closure, separately from exit. */
+			observedOutputClose() {
+				return this.#outputClosed;
+			}
 			/** Latest retained output and exit observation, with explicit configured truncation. */
 			snapshot() {
-				const outputIncomplete = this.launch.process.outputIncomplete === true;
+				const outputIncomplete = this.#outputIncomplete || this.launch.process.outputIncomplete === true;
 				return {
 					...this.#diagnosticTruncated || outputIncomplete ? { diagnosticTruncated: true } : {},
 					stdout: this.#stdout.snapshot(this.#stdoutObservedBytes),
@@ -547,8 +429,58 @@ function init_ProviderProcess() {
 					...outputIncomplete ? { outputIncomplete: true } : {}
 				};
 			}
+			/** Mark the current raw-byte position without copying or retaining output. */
+			checkpointOutput() {
+				const checkpoint = Object.freeze({});
+				outputCheckpoints.set(checkpoint, {
+					owner: this,
+					epoch: this.#outputEpoch,
+					stdout: this.#stdoutObservedBytes,
+					stderr: this.#stderrObservedBytes
+				});
+				return checkpoint;
+			}
+			/** Snapshot only bytes produced after a valid checkpoint on this supervisor. */
+			snapshotOutputSince(checkpoint) {
+				const position = typeof checkpoint === "object" && checkpoint !== null ? outputCheckpoints.get(checkpoint) : undefined;
+				if (position === undefined || position.owner !== this || position.epoch !== this.#outputEpoch) return {
+					snapshot: {
+						stdout: {
+							text: "",
+							bytes: 0,
+							observedBytes: 0
+						},
+						stderr: {
+							text: "",
+							bytes: 0,
+							observedBytes: 0
+						},
+						exitCode: this.#exitObservation?.code,
+						signal: this.#exitObservation?.signal,
+						outputIncomplete: true,
+						diagnosticTruncated: true
+					},
+					complete: false
+				};
+				const stdout = this.#stdout.snapshotRange(position.stdout, this.#stdoutObservedBytes);
+				const stderr = this.#stderr.snapshotRange(position.stderr, this.#stderrObservedBytes);
+				const incomplete = stdout.complete === false || stderr.complete === false || this.#outputIncomplete || this.launch.process.outputIncomplete === true;
+				return {
+					snapshot: {
+						...incomplete || this.#diagnosticTruncated ? { diagnosticTruncated: true } : {},
+						stdout: stdout.stream,
+						stderr: stderr.stream,
+						exitCode: this.#exitObservation?.code,
+						signal: this.#exitObservation?.signal,
+						...this.launch.process.memoryLimitReached === true ? { memoryLimitReached: true } : {},
+						...incomplete ? { outputIncomplete: true } : {}
+					},
+					complete: !incomplete && !this.#diagnosticTruncated
+				};
+			}
 			/** Begin a new observation on a retained process without retaining earlier output. */
 			resetOutput() {
+				this.#outputEpoch += 1;
 				this.#stdout.reset();
 				this.#stderr.reset();
 				this.#stdoutObservedBytes = 0;
@@ -559,9 +491,11 @@ function init_ProviderProcess() {
 			async waitForExit(timeoutMs) {
 				return waitForProcessEvent(this.#exitObservation !== undefined, this.#exit.promise, timeoutMs);
 			}
-			/** Wait until output streams close; WindowsOwnedProcess closes only after its whole Job Object settles. */
-			async waitForOutputClose(timeoutMs) {
-				return waitForProcessEvent(this.#outputClosed, this.#outputClose.promise, timeoutMs);
+			/** Wait until output streams close; omit the timeout to await physical completion.
+			* WindowsOwnedProcess closes only after its whole Job Object settles.
+			*/
+			async waitForOutputClose(timeoutMs, signal) {
+				return waitForProcessEvent(this.#outputClosed, this.#outputClose.promise, timeoutMs, signal);
 			}
 			/** Bound additional retained bytes while still draining all later output. */
 			limitAdditionalOutputBytes(maxBytes) {
@@ -588,6 +522,7 @@ function init_ProviderProcess() {
 			/** Detach capture and process listeners after an adapter releases ownership. */
 			dispose() {
 				if (this.#disposed) return;
+				if (!this.#outputClosed) this.#outputIncomplete = true;
 				this.#disposed = true;
 				this.launch.process.stdout?.off("data", this.#onStdout);
 				this.launch.process.stdout?.off("error", this.#onStdoutError);
@@ -614,11 +549,20 @@ function init_ProviderProcess() {
 				process.stderr?.ref?.();
 			}
 			async #stop(options) {
-				this.ref();
+				if (this.launch.ownsProcessLifetime) {
+					this.ref();
+					this.limitAdditionalOutputBytes(MAX_LATE_OUTPUT_BYTES);
+				}
 				let completed = false;
 				try {
 					const result = await this.#stopWithin(options);
 					completed = result.status !== "incomplete";
+					if (completed && result.status !== "not-owned" && !this.#outputClosed) {
+						if (!await this.waitForOutputClose(OUTPUT_CLOSE_GRACE_MS)) {
+							this.#outputIncomplete = true;
+							this.unref();
+						}
+					}
 					if (!completed) this.unref();
 					return result;
 				} finally {
@@ -687,9 +631,11 @@ function init_ProviderProcess() {
 				}
 			}
 			#recordStreamError(stream, cause) {
+				this.#outputIncomplete = true;
 				this.#options.onDiagnostic?.({
 					type: "error",
-					message: `${stream} stream failed: ${cause.message}`
+					message: `${stream} stream failed: ${cause.message}`,
+					cause
 				});
 			}
 			#capture(stream, capture, chunk) {
@@ -738,7 +684,28 @@ function init_ProviderProcess() {
 				this.#chunks.push(Buffer.from(chunk));
 			}
 			snapshot(observedBytes) {
-				const buffer = Buffer.concat(this.#chunks, this.#bytes);
+				return this.#snapshotBuffer(Buffer.concat(this.#chunks, this.#bytes), observedBytes);
+			}
+			snapshotRange(start, end) {
+				const availableEnd = Math.min(end, this.#bytes);
+				const availableStart = Math.min(start, availableEnd);
+				const chunks = [];
+				let offset = 0;
+				for (const chunk of this.#chunks) {
+					const chunkEnd = offset + chunk.byteLength;
+					const from = Math.max(availableStart, offset);
+					const to = Math.min(availableEnd, chunkEnd);
+					if (to > from) chunks.push(chunk.subarray(from - offset, to - offset));
+					offset = chunkEnd;
+					if (offset >= availableEnd) break;
+				}
+				const buffer = Buffer.concat(chunks, availableEnd - availableStart);
+				return {
+					stream: this.#snapshotBuffer(buffer, Math.max(0, end - start)),
+					complete: start <= this.#bytes && end <= this.#bytes
+				};
+			}
+			#snapshotBuffer(buffer, observedBytes) {
 				const text = buffer.toString("utf8");
 				let invalidUtf8 = false;
 				try {
@@ -748,7 +715,7 @@ function init_ProviderProcess() {
 				}
 				return {
 					text,
-					bytes: this.#bytes,
+					bytes: buffer.byteLength,
 					observedBytes,
 					...invalidUtf8 ? { invalidUtf8: true } : {}
 				};
@@ -778,36 +745,26 @@ function init_ProviderProcess() {
 			child.once("spawn", onSpawn);
 			child.once("error", onError);
 		});
-		waitForProcessEvent = async (observed, event, timeoutMs) => {
+		waitForProcessEvent = async (observed, event, timeoutMs, signal) => {
 			if (observed) return true;
+			if (signal?.aborted === true) return false;
 			let timer;
+			let onAbort;
 			try {
 				return await Promise.race([event.then(() => true), new Promise((resolve) => {
-					timer = setTimeout(() => resolve(false), Math.max(0, timeoutMs));
+					if (timeoutMs !== undefined) timer = setTimeout(() => resolve(false), Math.max(0, timeoutMs));
+					if (signal !== undefined) {
+						onAbort = () => resolve(false);
+						signal.addEventListener("abort", onAbort, { once: true });
+					}
 				})]);
 			} finally {
 				if (timer !== undefined) clearTimeout(timer);
+				if (onAbort !== undefined) signal?.removeEventListener("abort", onAbort);
 			}
 		};
 	})))();
 }
 
 //#endregion
-//#region dist/process/snapshotEnvironment.js
-var snapshotEnvironment;
-function init_snapshotEnvironment() {
-	return (init_snapshotEnvironment = __esmMin((() => {
-		snapshotEnvironment = (environment, platform = process.platform) => {
-			if (platform !== "win32") return Object.freeze({ ...environment });
-			const snapshot = {};
-			for (const key of Object.keys(environment).sort()) {
-				const canonicalKey = key.toUpperCase();
-				if (!Object.hasOwn(snapshot, canonicalKey)) snapshot[canonicalKey] = environment[key];
-			}
-			return Object.freeze(snapshot);
-		};
-	})))();
-}
-
-//#endregion
-export { ProviderProcessSupervisor, init_ProviderProcess, init_WindowsNativeLoader, init_snapshotEnvironment, requireWindowsNativeAuthority, snapshotEnvironment, spawnOwnedProviderProcess, systemWindowsNativeAuthority, windowsFileIdentitySchema, windowsHandleSchema };
+export { ProviderProcessSupervisor, init_ProviderProcess, spawnOwnedProviderProcess };

package/dist/cli-runtime/RegularFileRead-mbgGYtxe.js

@@ -0,0 +1,125 @@
+import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
+import { RegularFileCancelled, RegularFileChangedError, RegularFileCleanupFailure, RegularFileOperationCancelled, assertRegularFileActive, init_OwnedRegularFile, init_RegularFile, sameRegularFileState, withOwnedRegularFile } from "./OwnedRegularFile-D1f5nUCx.js";
+import { init_BoundedFileBytes, readBoundedFileBytes } from "./BoundedFileBytes-DRtiQNAQ.js";
+import { lstat, stat } from "node:fs/promises";
+
+//#region dist/application/RegularFileRead.js
+var InvalidUtf8FileError, retryRegularFileCleanup, retryRegularFileCleanupFailures, failureMessage, withRegularFile, readRegularFile, readRegularFileText, readRegularFileTextSnapshot, decodeFileText, readRegularFileContent;
+function init_RegularFileRead() {
+	return (init_RegularFileRead = __esmMin((() => {
+		init_RegularFile();
+		init_OwnedRegularFile();
+		init_BoundedFileBytes();
+		InvalidUtf8FileError = class extends TypeError {
+			path;
+			_tag = "InvalidUtf8FileError";
+			constructor(path, cause) {
+				super(`File is not valid UTF-8: ${path}`, { cause });
+				this.path = path;
+				this.name = this._tag;
+			}
+		};
+		retryRegularFileCleanup = async (failure, resources, signal) => {
+			const outcome = failure.outcome.kind === "failed" && failure.outcome.cause instanceof RegularFileOperationCancelled && !(signal?.aborted === true && failure.outcome.cause === signal.reason) ? {
+				kind: "failed",
+				cause: failure.outcome.cause.reason
+			} : failure.outcome;
+			const released = await resources.release({
+				kind: "file-handle",
+				handle: failure.owner,
+				resource: failure.path
+			});
+			if (released.kind === "released") return { outcome };
+			return {
+				outcome,
+				cleanup: {
+					reason: `${failureMessage(failure.cleanupCause)}; retry: ${failureMessage(released.cause)}`,
+					resources: [failure.path]
+				}
+			};
+		};
+		retryRegularFileCleanupFailures = async (failure, resources) => {
+			const failures = [];
+			const observations = [];
+			let current = failure;
+			let primary;
+			for (;;) {
+				failures.push(current);
+				const retried = await retryRegularFileCleanup(current, resources);
+				if (retried.cleanup !== undefined) observations.push(retried.cleanup);
+				primary = retried.outcome.kind === "failed" ? retried.outcome.cause : current.cleanupCause;
+				const nested = current.outcome.kind === "failed" ? current.outcome.cause : undefined;
+				if (!(nested instanceof RegularFileCleanupFailure)) break;
+				current = nested;
+			}
+			return {
+				primary,
+				failures,
+				...observations.length === 0 ? {} : { cleanup: {
+					reason: observations.map(({ reason }) => reason).join("; "),
+					resources: observations.flatMap(({ resources }) => resources)
+				} }
+			};
+		};
+		failureMessage = (cause) => cause instanceof Error ? cause.message : String(cause);
+		withRegularFile = async (path, read, options = {}) => {
+			const { signal, resources } = options;
+			let admitted;
+			const operation = async () => {
+				try {
+					return await withOwnedRegularFile(path, {
+						...signal === undefined ? {} : { signal },
+						symlinks: options.symlinks ?? "follow"
+					}, async (handle) => {
+						admitted = handle;
+						const stats = await handle.stat();
+						assertRegularFileActive(signal);
+						const value = await read(handle, stats);
+						assertRegularFileActive(signal);
+						const [opened, currentPath] = await Promise.all([handle.stat(), options.symlinks === "reject" ? lstat(path) : stat(path)]);
+						if (!sameRegularFileState(stats, opened) || !sameRegularFileState(stats, currentPath)) throw new RegularFileChangedError(path);
+						assertRegularFileActive(signal);
+						return value;
+					});
+				} catch (cause) {
+					if (signal?.aborted === true && cause === signal.reason) throw cause;
+					if (cause instanceof RegularFileOperationCancelled) throw cause.reason;
+					if (cause instanceof RegularFileCancelled && cause.owner.handle === admitted) throw cause.reason;
+					if (!(cause instanceof RegularFileCleanupFailure) || resources === undefined) throw cause;
+					const retry = await retryRegularFileCleanup(cause, resources, signal);
+					if (retry.cleanup !== undefined) throw cause;
+					if (retry.outcome.kind === "failed") throw retry.outcome.cause;
+					return retry.outcome.value;
+				}
+			};
+			const value = await (resources === undefined ? operation() : resources.run(operation));
+			signal?.throwIfAborted();
+			return value;
+		};
+		readRegularFile = (path, options = {}) => readRegularFileContent(path, (bytes) => bytes, options);
+		readRegularFileText = (path, options = {}) => readRegularFileContent(path, (bytes) => decodeFileText(path, bytes), options);
+		readRegularFileTextSnapshot = (path, options = {}) => readRegularFileContent(path, (bytes, state) => ({
+			text: decodeFileText(path, bytes),
+			state
+		}), options);
+		decodeFileText = (path, bytes) => {
+			try {
+				return new TextDecoder("utf-8", {
+					fatal: true,
+					ignoreBOM: true
+				}).decode(bytes);
+			} catch (cause) {
+				if (!(cause instanceof TypeError)) throw cause;
+				throw new InvalidUtf8FileError(path, cause);
+			}
+		};
+		readRegularFileContent = (path, decode, options) => withRegularFile(path, async (handle, stats) => {
+			const bytes = await readBoundedFileBytes(handle, stats.size, options.signal);
+			if (bytes === undefined || bytes.length !== stats.size) throw new RegularFileChangedError(path);
+			return decode(bytes, stats);
+		}, options);
+	})))();
+}
+
+//#endregion
+export { InvalidUtf8FileError, init_RegularFileRead, readRegularFile, readRegularFileText, readRegularFileTextSnapshot, retryRegularFileCleanup, retryRegularFileCleanupFailures, withRegularFile };