privateer-agent 0.15.4 → 0.15.6

package/dist-boot/c-DR7XQI32.mjs

@@ -0,0 +1,381 @@
+import{createRequire as __pvCR}from"node:module";import{fileURLToPath as __pvF}from"node:url";import{dirname as __pvD}from"node:path";const require=__pvCR(import.meta.url);const __pvUrl=(r)=>new URL(r,import.meta.url).href;const __pvFile=(r)=>__pvF(new URL(r,import.meta.url));
+import {
+  __name
+} from "./c-CN77DCGF.mjs";
+
+// node_modules/pi-background-tasks/src/core/durable-fs.ts?ext=pi-background-tasks
+import { randomBytes } from "node:crypto";
+import { open as nodeOpen, rename as nodeRename, rm as nodeRm } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+var DurableFileCancellationError = class extends Error {
+  static {
+    __name(this, "DurableFileCancellationError");
+  }
+  code = "durable_file_cancelled";
+  path;
+  reason;
+  cleanupFailures;
+  targetPath;
+  temporaryPath;
+  renameCompleted;
+  constructor(input) {
+    const reasonText = describeCause(input.reason);
+    const cleanupText = input.cleanupFailures.length === 0 ? "" : ` Cleanup failures: ${input.cleanupFailures.map(formatFailureForMessage).join("; ")}`;
+    const commitText = input.renameCompleted ? ` Replacement may already be visible at ${input.targetPath ?? input.path}.` : "";
+    super(`Durable file operation cancelled for ${input.path}: ${reasonText}.${commitText}${cleanupText}`);
+    this.name = "DurableFileCancellationError";
+    this.path = input.path;
+    this.reason = input.reason;
+    this.cleanupFailures = [...input.cleanupFailures];
+    this.targetPath = input.targetPath;
+    this.temporaryPath = input.temporaryPath;
+    this.renameCompleted = input.renameCompleted;
+  }
+};
+var DurableFileError = class extends Error {
+  static {
+    __name(this, "DurableFileError");
+  }
+  operation;
+  path;
+  nativeCode;
+  primaryCause;
+  cleanupFailures;
+  targetPath;
+  temporaryPath;
+  renameCompleted;
+  constructor(input) {
+    super(formatDurableMessage(input));
+    this.name = "DurableFileError";
+    this.operation = input.operation;
+    this.path = input.path;
+    this.nativeCode = nativeCodeForCause(input.cause);
+    this.primaryCause = input.cause;
+    this.cleanupFailures = [...input.cleanupFailures];
+    this.targetPath = input.targetPath;
+    this.temporaryPath = input.temporaryPath;
+    this.renameCompleted = input.renameCompleted;
+  }
+};
+function failure(operation, path, cause) {
+  return { operation, path, cause };
+}
+__name(failure, "failure");
+function durableError(input) {
+  return new DurableFileError(input);
+}
+__name(durableError, "durableError");
+function nativeCodeForCause(cause) {
+  if (typeof cause !== "object" || cause === null) return void 0;
+  const code = Reflect.get(cause, "code");
+  return typeof code === "string" ? code : void 0;
+}
+__name(nativeCodeForCause, "nativeCodeForCause");
+function describeCause(cause) {
+  if (cause instanceof Error) {
+    const message = cause.message.length > 0 ? cause.message : String(cause);
+    return `${cause.name}: ${message}`;
+  }
+  return String(cause);
+}
+__name(describeCause, "describeCause");
+function formatFailureForMessage(entry) {
+  const code = nativeCodeForCause(entry.cause);
+  const codeText = code === void 0 ? "" : ` (code ${code})`;
+  return `${entry.operation} ${entry.path}${codeText}: ${describeCause(entry.cause)}`;
+}
+__name(formatFailureForMessage, "formatFailureForMessage");
+function formatDurableMessage(input) {
+  const primary = formatFailureForMessage({
+    operation: input.operation,
+    path: input.path,
+    cause: input.cause
+  });
+  const segments = [`Durable file operation failed: ${primary}`];
+  if (input.targetPath !== void 0) segments.push(`target: ${input.targetPath}`);
+  if (input.temporaryPath !== void 0) segments.push(`temporary: ${input.temporaryPath}`);
+  if (input.renameCompleted) {
+    const target = input.targetPath ?? input.path;
+    segments.push(`Replacement may already be visible at ${target}.`);
+  }
+  if (input.cleanupFailures.length > 0) {
+    const cleanupText = input.cleanupFailures.map(formatFailureForMessage).join("; ");
+    segments.push(`Cleanup failures: ${cleanupText}`);
+  }
+  return segments.join(" ");
+}
+__name(formatDurableMessage, "formatDurableMessage");
+async function writeSyncClose(handle, path, data, signal) {
+  const cleanupFailures = [];
+  let primaryFailure;
+  let cancelled = signal?.aborted === true;
+  if (!cancelled) {
+    try {
+      await handle.writeFile(data);
+    } catch (error) {
+      primaryFailure = failure("write_file", path, error);
+    }
+    cancelled = signal?.aborted === true;
+  }
+  if (primaryFailure === void 0 && !cancelled) {
+    try {
+      await handle.sync();
+    } catch (error) {
+      primaryFailure = failure("sync_file", path, error);
+    }
+    cancelled = signal?.aborted === true;
+  }
+  try {
+    await handle.close();
+  } catch (error) {
+    const closeFailure = failure("close_file", path, error);
+    if (primaryFailure === void 0) primaryFailure = closeFailure;
+    else cleanupFailures.push(closeFailure);
+  }
+  cancelled ||= signal?.aborted === true;
+  return { primaryFailure, cleanupFailures, cancelled };
+}
+__name(writeSyncClose, "writeSyncClose");
+async function syncCloseDirectory(handle, path) {
+  const cleanupFailures = [];
+  let primaryFailure;
+  try {
+    await handle.sync();
+  } catch (error) {
+    primaryFailure = failure("sync_directory", path, error);
+  }
+  try {
+    await handle.close();
+  } catch (error) {
+    const closeFailure = failure("close_directory", path, error);
+    if (primaryFailure === void 0) primaryFailure = closeFailure;
+    else cleanupFailures.push(closeFailure);
+  }
+  return { primaryFailure, cleanupFailures, cancelled: false };
+}
+__name(syncCloseDirectory, "syncCloseDirectory");
+function cancellationReason(signal) {
+  return signal.reason ?? new Error("operation aborted");
+}
+__name(cancellationReason, "cancellationReason");
+function throwCancellation(signal, path, cleanupFailures, targetPath, temporaryPath, renameCompleted) {
+  const reason = cancellationReason(signal);
+  if (cleanupFailures.length === 0 && !renameCompleted && reason instanceof Error) throw reason;
+  throw new DurableFileCancellationError({
+    path,
+    reason,
+    cleanupFailures,
+    targetPath,
+    temporaryPath,
+    renameCompleted
+  });
+}
+__name(throwCancellation, "throwCancellation");
+function throwDurable(primaryFailure, cleanupFailures, targetPath, temporaryPath, renameCompleted) {
+  throw durableError({
+    operation: primaryFailure.operation,
+    path: primaryFailure.path,
+    cause: primaryFailure.cause,
+    cleanupFailures,
+    targetPath,
+    temporaryPath,
+    renameCompleted
+  });
+}
+__name(throwDurable, "throwDurable");
+async function removeTemporary(operations, temporaryPath, cleanupFailures) {
+  try {
+    await operations.remove(temporaryPath);
+  } catch (error) {
+    cleanupFailures.push(failure("remove_temp", temporaryPath, error));
+  }
+}
+__name(removeTemporary, "removeTemporary");
+function isAborted(signal) {
+  return signal?.aborted === true;
+}
+__name(isAborted, "isAborted");
+async function writeWithOperations(operations, path, data, options) {
+  const signal = options.signal;
+  if (signal !== void 0 && isAborted(signal))
+    throwCancellation(signal, path, [], path, void 0, false);
+  let handle;
+  try {
+    handle = await operations.openWritable(path, "w");
+  } catch (error) {
+    if (signal !== void 0 && isAborted(signal))
+      throwCancellation(signal, path, [], path, void 0, false);
+    throwDurable(failure("open_file", path, error), [], path, void 0, false);
+  }
+  const result = await writeSyncClose(handle, path, data, signal);
+  if (result.primaryFailure !== void 0) {
+    throwDurable(result.primaryFailure, result.cleanupFailures, path, void 0, false);
+  }
+  if (result.cancelled && signal !== void 0) {
+    throwCancellation(signal, path, result.cleanupFailures, path, void 0, false);
+  }
+}
+__name(writeWithOperations, "writeWithOperations");
+async function syncDirectoryAfterRename(operations, targetPath, temporaryPath) {
+  if (operations.platform === "win32") return;
+  const directoryPath = dirname(targetPath);
+  let handle;
+  try {
+    handle = await operations.openDirectory(directoryPath);
+  } catch (error) {
+    throwDurable(failure("open_directory", directoryPath, error), [], targetPath, temporaryPath, true);
+  }
+  const result = await syncCloseDirectory(handle, directoryPath);
+  if (result.primaryFailure !== void 0) {
+    throwDurable(result.primaryFailure, result.cleanupFailures, targetPath, temporaryPath, true);
+  }
+}
+__name(syncDirectoryAfterRename, "syncDirectoryAfterRename");
+async function replaceWithOperations(operations, path, data, options) {
+  const signal = options.signal;
+  if (signal !== void 0 && isAborted(signal))
+    throwCancellation(signal, path, [], path, void 0, false);
+  const temporaryPath = operations.temporaryPath(path);
+  let handle;
+  try {
+    handle = await operations.openWritable(temporaryPath, "wx", 384);
+  } catch (error) {
+    if (signal !== void 0 && isAborted(signal))
+      throwCancellation(signal, temporaryPath, [], path, temporaryPath, false);
+    throwDurable(failure("open_file", temporaryPath, error), [], path, temporaryPath, false);
+  }
+  const writeResult = await writeSyncClose(handle, temporaryPath, data, signal);
+  if (writeResult.primaryFailure !== void 0) {
+    await removeTemporary(operations, temporaryPath, writeResult.cleanupFailures);
+    throwDurable(writeResult.primaryFailure, writeResult.cleanupFailures, path, temporaryPath, false);
+  }
+  if (writeResult.cancelled && signal !== void 0) {
+    await removeTemporary(operations, temporaryPath, writeResult.cleanupFailures);
+    throwCancellation(
+      signal,
+      temporaryPath,
+      writeResult.cleanupFailures,
+      path,
+      temporaryPath,
+      false
+    );
+  }
+  const renameResult = await renameWithWindowsContention(
+    operations,
+    temporaryPath,
+    path,
+    signal
+  );
+  if (renameResult.cancelled && signal !== void 0) {
+    const cleanupFailures = [];
+    await removeTemporary(operations, temporaryPath, cleanupFailures);
+    throwCancellation(signal, temporaryPath, cleanupFailures, path, temporaryPath, false);
+  }
+  if (renameResult.error !== void 0) {
+    const cleanupFailures = [];
+    await removeTemporary(operations, temporaryPath, cleanupFailures);
+    throwDurable(
+      failure("rename_file", path, renameResult.error),
+      cleanupFailures,
+      path,
+      temporaryPath,
+      false
+    );
+  }
+  await syncDirectoryAfterRename(operations, path, temporaryPath);
+  if (signal !== void 0 && isAborted(signal)) {
+    throwCancellation(signal, path, [], path, temporaryPath, true);
+  }
+}
+__name(replaceWithOperations, "replaceWithOperations");
+var WINDOWS_RENAME_CONTENTION_CODES = /* @__PURE__ */ new Set([
+  "EPERM",
+  "EACCES",
+  "EBUSY"
+]);
+var WINDOWS_RENAME_ATTEMPTS = 10;
+var WINDOWS_RENAME_RETRY_DELAY_MS = 20;
+function delay(ms, signal) {
+  if (isAborted(signal)) return Promise.resolve();
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", aborted);
+      resolve();
+    }, ms);
+    const aborted = /* @__PURE__ */ __name(() => {
+      clearTimeout(timer);
+      resolve();
+    }, "aborted");
+    signal?.addEventListener("abort", aborted, { once: true });
+  });
+}
+__name(delay, "delay");
+async function renameWithWindowsContention(operations, temporaryPath, targetPath, signal) {
+  const attempts = operations.platform === "win32" ? WINDOWS_RENAME_ATTEMPTS : 1;
+  let lastError;
+  for (let attempt = 1; attempt <= attempts; attempt++) {
+    if (isAborted(signal)) return { error: void 0, cancelled: true };
+    try {
+      await operations.rename(temporaryPath, targetPath);
+      return { error: void 0, cancelled: false };
+    } catch (error) {
+      lastError = error;
+      if (isAborted(signal)) return { error: void 0, cancelled: true };
+      const code = nativeCodeForCause(error);
+      const retryable = operations.platform === "win32" && code !== void 0 && WINDOWS_RENAME_CONTENTION_CODES.has(code);
+      if (!retryable || attempt === attempts) return { error, cancelled: false };
+      await delay(WINDOWS_RENAME_RETRY_DELAY_MS * attempt, signal);
+    }
+  }
+  return { error: lastError, cancelled: false };
+}
+__name(renameWithWindowsContention, "renameWithWindowsContention");
+function temporaryPathForTarget(target) {
+  return join(
+    dirname(target),
+    `.${basename(target)}.${String(process.pid)}.${randomBytes(6).toString("hex")}.tmp`
+  );
+}
+__name(temporaryPathForTarget, "temporaryPathForTarget");
+var nodeOperations = {
+  platform: process.platform,
+  async openWritable(path, flag, mode) {
+    if (mode === void 0) return nodeOpen(path, flag);
+    return nodeOpen(path, flag, mode);
+  },
+  async openDirectory(path) {
+    return nodeOpen(path, "r");
+  },
+  async rename(source, target) {
+    await nodeRename(source, target);
+  },
+  async remove(path) {
+    await nodeRm(path, { force: true });
+  },
+  temporaryPath: temporaryPathForTarget
+};
+var defaultWriter = createDurableFileWriter(nodeOperations);
+function createDurableFileWriter(operations) {
+  return {
+    async write(path, data, options = {}) {
+      await writeWithOperations(operations, path, data, options);
+    },
+    async replace(path, data, options = {}) {
+      await replaceWithOperations(operations, path, data, options);
+    }
+  };
+}
+__name(createDurableFileWriter, "createDurableFileWriter");
+async function writeFileDurable(path, data, options = {}) {
+  await defaultWriter.write(path, data, options);
+}
+__name(writeFileDurable, "writeFileDurable");
+async function replaceFileDurable(path, data, options = {}) {
+  await defaultWriter.replace(path, data, options);
+}
+__name(replaceFileDurable, "replaceFileDurable");
+
+export {
+  writeFileDurable,
+  replaceFileDurable
+};