@ricsam/r5d-worker 0.0.132 → 0.0.134

package/dist/cjs/atomic-rename.cjs

@@ -0,0 +1,303 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var atomic_rename_exports = {};
+__export(atomic_rename_exports, {
+  AtomicRenameError: () => AtomicRenameError,
+  atomicRenamePrimitivesFor: () => atomicRenamePrimitivesFor,
+  atomicRenameSupport: () => atomicRenameSupport,
+  exchangePaths: () => exchangePaths,
+  isAtomicRenameUnsupported: () => isAtomicRenameUnsupported,
+  overrideAtomicRenameSupportForTests: () => overrideAtomicRenameSupportForTests,
+  probeAtomicRenameSupport: () => probeAtomicRenameSupport,
+  renameNoReplace: () => renameNoReplace,
+  resetAtomicRenameProbesForTests: () => resetAtomicRenameProbesForTests
+});
+module.exports = __toCommonJS(atomic_rename_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_os = __toESM(require("node:os"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_node_crypto = require("node:crypto");
+class AtomicRenameError extends Error {
+  constructor(syscall, code, errno, path2, dest) {
+    super(`${code}: ${syscall} failed, ${path2} -> ${dest}`);
+    this.syscall = syscall;
+    this.code = code;
+    this.errno = errno;
+    this.path = path2;
+    this.dest = dest;
+    this.name = "AtomicRenameError";
+  }
+  syscall;
+  code;
+  errno;
+  path;
+  dest;
+}
+const UNSUPPORTED_CODES = /* @__PURE__ */ new Set(["EINVAL", "ENOSYS", "ENOTSUP", "EOPNOTSUPP", "EPERM"]);
+function isAtomicRenameUnsupported(error) {
+  return error instanceof AtomicRenameError && UNSUPPORTED_CODES.has(error.code);
+}
+const LINUX_AT_FDCWD = -100;
+const LINUX_RENAME_NOREPLACE = 1;
+const LINUX_RENAME_EXCHANGE = 2;
+const DARWIN_RENAME_SWAP = 2;
+const DARWIN_RENAME_EXCL = 4;
+const LINUX_SYS_RENAMEAT2 = { x64: 316, arm64: 276 };
+const PROBE_PREFIX = ".r5d-atomic-rename-probe-";
+let loaded = null;
+let override = null;
+const errnoNames = /* @__PURE__ */ new Map();
+for (const [name, value] of Object.entries(import_node_os.default.constants.errno)) errnoNames.set(value, name);
+function errnoCode(errno) {
+  return errnoNames.get(errno) ?? `E${errno}`;
+}
+function cString(value) {
+  return Buffer.from(`${value}\0`, "utf8");
+}
+function loadNative() {
+  if (loaded) return loaded;
+  loaded = { calls: null, detail: "not attempted" };
+  try {
+    const ffi = require("bun:ffi");
+    const { dlopen, FFIType, ptr, read } = ffi;
+    if (process.platform === "darwin") {
+      const lib = dlopen("libSystem.B.dylib", {
+        renamex_np: { args: [FFIType.ptr, FFIType.ptr, FFIType.u32], returns: FFIType.i32 },
+        __error: { args: [], returns: FFIType.ptr }
+      });
+      loaded = {
+        calls: {
+          rename2: (from, to, flags) => {
+            const fromBuffer = cString(from);
+            const toBuffer = cString(to);
+            return lib.symbols.renamex_np(ptr(fromBuffer), ptr(toBuffer), flags);
+          },
+          errno: () => read.i32(lib.symbols.__error(), 0),
+          exchangeFlag: DARWIN_RENAME_SWAP,
+          noReplaceFlag: DARWIN_RENAME_EXCL,
+          backend: "renamex_np"
+        }
+      };
+      return loaded;
+    }
+    if (process.platform === "linux") {
+      const errnoLib = dlopen("libc.so.6", { __errno_location: { args: [], returns: FFIType.ptr } });
+      const errno = () => read.i32(errnoLib.symbols.__errno_location(), 0);
+      try {
+        const lib = dlopen("libc.so.6", {
+          renameat2: { args: [FFIType.i32, FFIType.ptr, FFIType.i32, FFIType.ptr, FFIType.u32], returns: FFIType.i32 }
+        });
+        loaded = {
+          calls: {
+            rename2: (from, to, flags) => {
+              const fromBuffer = cString(from);
+              const toBuffer = cString(to);
+              return lib.symbols.renameat2(LINUX_AT_FDCWD, ptr(fromBuffer), LINUX_AT_FDCWD, ptr(toBuffer), flags);
+            },
+            errno,
+            exchangeFlag: LINUX_RENAME_EXCHANGE,
+            noReplaceFlag: LINUX_RENAME_NOREPLACE,
+            backend: "renameat2"
+          }
+        };
+        return loaded;
+      } catch (error) {
+        const number = LINUX_SYS_RENAMEAT2[process.arch];
+        if (number === void 0) {
+          loaded = { calls: null, detail: `renameat2 symbol unavailable and no syscall number for ${process.arch}: ${String(error)}` };
+          return loaded;
+        }
+        const lib = dlopen("libc.so.6", {
+          syscall: {
+            args: [FFIType.i64, FFIType.i64, FFIType.i64, FFIType.i64, FFIType.i64, FFIType.i64],
+            returns: FFIType.i64
+          }
+        });
+        loaded = {
+          calls: {
+            rename2: (from, to, flags) => {
+              const fromBuffer = cString(from);
+              const toBuffer = cString(to);
+              return Number(
+                lib.symbols.syscall(number, LINUX_AT_FDCWD, Number(ptr(fromBuffer)), LINUX_AT_FDCWD, Number(ptr(toBuffer)), flags)
+              );
+            },
+            errno,
+            exchangeFlag: LINUX_RENAME_EXCHANGE,
+            noReplaceFlag: LINUX_RENAME_NOREPLACE,
+            backend: "syscall"
+          }
+        };
+        return loaded;
+      }
+    }
+    loaded = { calls: null, detail: `no atomic exchange primitive on ${process.platform}` };
+  } catch (error) {
+    loaded = { calls: null, detail: `bun:ffi unavailable: ${error instanceof Error ? error.message : String(error)}` };
+  }
+  return loaded;
+}
+function applyOverride(support) {
+  if (override?.exchange !== void 0) support.exchange = override.exchange;
+  if (override?.noReplace !== void 0) support.noReplace = override.noReplace;
+  return support;
+}
+function atomicRenameSupport() {
+  const native = loadNative();
+  return applyOverride(
+    native.calls ? { platform: process.platform, exchange: native.calls.backend, noReplace: native.calls.backend } : { platform: process.platform, exchange: "unavailable", noReplace: "link", detail: native.detail }
+  );
+}
+function overrideAtomicRenameSupportForTests(value) {
+  override = value;
+}
+function resetAtomicRenameProbesForTests() {
+  probes.clear();
+}
+function call(native, syscall, from, to, flags) {
+  if (native.rename2(from, to, flags) === 0) return;
+  const errno = native.errno();
+  throw new AtomicRenameError(syscall, errnoCode(errno), errno, from, to);
+}
+function exchangeWith(support, a, b) {
+  const native = loadNative().calls;
+  if (support.exchange === "unavailable" || !native) {
+    throw new AtomicRenameError("exchange", "ENOSYS", import_node_os.default.constants.errno.ENOSYS, a, b);
+  }
+  call(native, support.exchange, a, b, native.exchangeFlag);
+}
+function renameNoReplaceWith(support, from, to) {
+  const native = loadNative().calls;
+  if (support.noReplace !== "link" && native) {
+    call(native, support.noReplace, from, to, native.noReplaceFlag);
+    return;
+  }
+  const source = import_node_fs.default.lstatSync(from);
+  if (!source.isFile()) throw new AtomicRenameError("link", "ENOTSUP", import_node_os.default.constants.errno.ENOTSUP, from, to);
+  try {
+    import_node_fs.default.linkSync(from, to);
+  } catch (error) {
+    const code = error.code ?? "EIO";
+    throw new AtomicRenameError("link", code, error.errno ?? 0, from, to);
+  }
+  import_node_fs.default.unlinkSync(from);
+}
+function exchangePaths(a, b) {
+  exchangeWith(atomicRenameSupport(), a, b);
+}
+function renameNoReplace(from, to) {
+  renameNoReplaceWith(atomicRenameSupport(), from, to);
+}
+const probes = /* @__PURE__ */ new Map();
+function withoutTemporaries(directory, run) {
+  const token = (0, import_node_crypto.randomUUID)();
+  const a = import_node_path.default.join(directory, `${PROBE_PREFIX}${token}-a`);
+  const b = import_node_path.default.join(directory, `${PROBE_PREFIX}${token}-b`);
+  try {
+    run(a, b);
+  } finally {
+    import_node_fs.default.rmSync(a, { force: true });
+    import_node_fs.default.rmSync(b, { force: true });
+  }
+}
+function createProbeFile(filePath, content) {
+  const descriptor = import_node_fs.default.openSync(filePath, import_node_fs.default.constants.O_WRONLY | import_node_fs.default.constants.O_CREAT | import_node_fs.default.constants.O_EXCL, 384);
+  try {
+    import_node_fs.default.writeSync(descriptor, content);
+    return import_node_fs.default.fstatSync(descriptor);
+  } finally {
+    import_node_fs.default.closeSync(descriptor);
+  }
+}
+function probeAtomicRenameSupport(directory) {
+  const native = atomicRenameSupport();
+  const dev = import_node_fs.default.lstatSync(directory).dev;
+  const cached = probes.get(dev);
+  if (cached) return applyOverride({ ...cached });
+  const probed = { ...native };
+  if (native.exchange !== "unavailable") {
+    withoutTemporaries(directory, (a, b) => {
+      const statA = createProbeFile(a, "a");
+      const statB = createProbeFile(b, "b");
+      let swapped = false;
+      let detail;
+      try {
+        exchangeWith(native, a, b);
+        const afterA = import_node_fs.default.lstatSync(a);
+        const afterB = import_node_fs.default.lstatSync(b);
+        swapped = afterA.ino === statB.ino && afterB.ino === statA.ino;
+        if (!swapped) detail = `exchange flag ignored by the filesystem holding ${directory}`;
+      } catch (error) {
+        detail = `exchange rejected by the filesystem holding ${directory}: ${error instanceof Error ? error.message : String(error)}`;
+      }
+      if (!swapped) {
+        probed.exchange = "unavailable";
+        probed.detail = detail;
+      }
+    });
+  }
+  if (native.noReplace !== "link") {
+    withoutTemporaries(directory, (a, b) => {
+      createProbeFile(a, "a");
+      createProbeFile(b, "b");
+      let refused = false;
+      try {
+        renameNoReplaceWith(native, a, b);
+      } catch (error) {
+        refused = error instanceof AtomicRenameError && error.code === "EEXIST";
+      }
+      if (!refused) {
+        probed.noReplace = "link";
+        probed.detail = `${probed.detail ? `${probed.detail}; ` : ""}no-replace flag ignored by the filesystem holding ${directory}`;
+      }
+    });
+  }
+  probes.set(dev, probed);
+  return applyOverride({ ...probed });
+}
+function atomicRenamePrimitivesFor(directory) {
+  const support = probeAtomicRenameSupport(directory);
+  return {
+    support,
+    exchange: (a, b) => exchangeWith(support, a, b),
+    renameNoReplace: (from, to) => renameNoReplaceWith(support, from, to)
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AtomicRenameError,
+  atomicRenamePrimitivesFor,
+  atomicRenameSupport,
+  exchangePaths,
+  isAtomicRenameUnsupported,
+  overrideAtomicRenameSupportForTests,
+  probeAtomicRenameSupport,
+  renameNoReplace,
+  resetAtomicRenameProbesForTests
+});

package/dist/cjs/git-blob-hash.cjs

@@ -0,0 +1,41 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var git_blob_hash_exports = {};
+__export(git_blob_hash_exports, {
+  gitBlobHash: () => gitBlobHash,
+  gitObjectHashAlgorithmFor: () => gitObjectHashAlgorithmFor
+});
+module.exports = __toCommonJS(git_blob_hash_exports);
+var import_node_crypto = require("node:crypto");
+function gitObjectHashAlgorithmFor(objectId) {
+  if (/^[0-9a-f]{40}$/u.test(objectId)) return "sha1";
+  if (/^[0-9a-f]{64}$/u.test(objectId)) return "sha256";
+  return null;
+}
+function gitBlobHash(content, algorithm) {
+  const hash = (0, import_node_crypto.createHash)(algorithm);
+  hash.update(`blob ${content.length}\0`);
+  hash.update(content);
+  return hash.digest("hex");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  gitBlobHash,
+  gitObjectHashAlgorithmFor
+});