farming-code 2.2.30 → 2.2.32

package/backend/auth.cjs

@@ -0,0 +1,261 @@
+// Generated by scripts/build-backend-runtime.ts. Do not edit.
+"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 auth_exports = {};
+__export(auth_exports, {
+  TokenAuth: () => TokenAuth,
+  decodeCookieToken: () => decodeCookieToken,
+  encodeCookieToken: () => encodeCookieToken,
+  generatePoeticToken: () => import_haiku_token.generatePoeticToken,
+  getPoeticTokenEntropyBits: () => import_haiku_token.getPoeticTokenEntropyBits
+});
+module.exports = __toCommonJS(auth_exports);
+var import_haiku_token = require("./haiku-token.cjs");
+var import_farming_net_pass = require("./farming-net-pass.cjs");
+var storageLayout = __toESM(require("./storage-layout.cjs"));
+const crypto = require("crypto");
+const fs = require("fs");
+function normalizeBasePath(basePath) {
+  const normalized = String(basePath || "");
+  if (!normalized || normalized === "/") return "";
+  return normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
+}
+function isTruthyEnv(value) {
+  return ["1", "true", "yes", "on"].includes(String(value || "").toLowerCase());
+}
+function encodeCookieToken(token) {
+  return encodeURIComponent(String(token));
+}
+function decodeCookieToken(token) {
+  try {
+    return decodeURIComponent(token);
+  } catch {
+    return token;
+  }
+}
+function normalizeCookieName(value) {
+  const cookieName = String(value || "").trim();
+  return /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/.test(cookieName) ? cookieName : "farming_token";
+}
+function normalizeCookiePath(value) {
+  const cookiePath = String(value || "/").trim();
+  if (!cookiePath.startsWith("/") || /[;\r\n]/.test(cookiePath)) return "/";
+  return cookiePath;
+}
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function readExistingTokenFile(tokenFile) {
+  try {
+    const token = fs.readFileSync(tokenFile, "utf8").trim();
+    return token || "";
+  } catch {
+    return "";
+  }
+}
+class TokenAuth {
+  disabled;
+  basePath;
+  authStatusPath;
+  cookieName;
+  cookiePath;
+  redirectQueryToken;
+  tokenFile;
+  token;
+  tokenInfo;
+  farmingNetPassVerifier;
+  constructor(options = {}) {
+    const authEnv = options.env || process.env;
+    this.disabled = options.disabled === true || isTruthyEnv(authEnv.FARMING_DISABLE_AUTH);
+    this.basePath = normalizeBasePath(options.basePath || "/");
+    this.authStatusPath = this.basePath ? `${this.basePath}/api/auth/status` : "/api/auth/status";
+    this.cookieName = normalizeCookieName(options.cookieName);
+    this.cookiePath = normalizeCookiePath(options.cookiePath);
+    this.redirectQueryToken = options.redirectQueryToken === true;
+    this.tokenFile = "";
+    this.token = "";
+    this.tokenInfo = null;
+    this.farmingNetPassVerifier = null;
+    if (this.disabled) {
+      return;
+    }
+    const farmingDir = options.farmingDir || storageLayout.farmingConfigDir();
+    if (!fs.existsSync(farmingDir)) {
+      fs.mkdirSync(farmingDir, { recursive: true });
+    }
+    this.tokenFile = storageLayout.sessionTokenFile(farmingDir);
+    if (options.farmingNetPassVerifier !== false) {
+      this.farmingNetPassVerifier = options.farmingNetPassVerifier || new import_farming_net_pass.FarmingNetPassVerifier({
+        trustFile: options.farmingNetTrustFile || storageLayout.farmingNetTrustFile(farmingDir)
+      });
+    }
+    const configuredTokenSource = Object.prototype.hasOwnProperty.call(options, "token") ? options.token : authEnv.FARMING_TOKEN;
+    const configuredToken = String(configuredTokenSource || "").trim();
+    const existingToken = configuredToken ? "" : readExistingTokenFile(this.tokenFile);
+    if (configuredToken) {
+      this.token = configuredToken;
+      this.tokenInfo = {
+        token: configuredToken,
+        style: "configured",
+        source: "FARMING_TOKEN",
+        entropyBits: 0
+      };
+    } else if (existingToken) {
+      this.token = existingToken;
+      this.tokenInfo = {
+        token: this.token,
+        style: "persisted",
+        source: this.tokenFile,
+        entropyBits: 0
+      };
+    } else {
+      this.tokenInfo = (0, import_haiku_token.createPoeticToken)({ locale: options.tokenLocale, env: authEnv, timeZone: options.timeZone });
+      this.token = this.tokenInfo.token;
+    }
+    this.saveTokenFile();
+  }
+  saveTokenFile() {
+    if (this.disabled || !this.tokenFile) return;
+    fs.writeFileSync(this.tokenFile, this.token, { mode: 384 });
+  }
+  isEnabled() {
+    return !this.disabled;
+  }
+  getToken() {
+    return this.token;
+  }
+  getTokenFile() {
+    return this.tokenFile;
+  }
+  getTokenInfo() {
+    return this.tokenInfo;
+  }
+  getCookieName() {
+    return this.cookieName;
+  }
+  verify(token) {
+    if (this.disabled) return true;
+    if (!token || !this.token) return false;
+    try {
+      const a = Buffer.from(String(token));
+      const b = Buffer.from(this.token);
+      if (a.length !== b.length) return false;
+      return crypto.timingSafeEqual(a, b);
+    } catch {
+      return false;
+    }
+  }
+  extractToken(req) {
+    const url = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
+    const queryToken = url.searchParams.get("token");
+    if (queryToken) return queryToken;
+    return this.extractCookieToken(req);
+  }
+  extractCookieToken(req) {
+    const cookies = req.headers.cookie || "";
+    const match = cookies.match(new RegExp(`(?:^|;\\s*)${escapeRegExp(this.cookieName)}=([^;]+)`));
+    if (match) return decodeCookieToken(match[1]);
+    return null;
+  }
+  setAuthenticatedCookie(res) {
+    res.setHeader(
+      "Set-Cookie",
+      `${this.cookieName}=${encodeCookieToken(this.token)}; Path=${this.cookiePath}; HttpOnly; SameSite=Lax`
+    );
+  }
+  redirectWithoutQueryParameter(res, url, parameter) {
+    url.searchParams.delete(parameter);
+    const search = url.searchParams.toString();
+    res.writeHead(302, {
+      "Cache-Control": "no-store",
+      Location: `${url.pathname}${search ? `?${search}` : ""}`
+    });
+    res.end();
+  }
+  middleware() {
+    return (req, res, next) => {
+      if (this.disabled) return next();
+      const url = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
+      if (url.pathname === this.authStatusPath) {
+        return next();
+      }
+      const method = String(req.method || "GET").toUpperCase();
+      if (["GET", "HEAD"].includes(method) && url.searchParams.has(import_farming_net_pass.PASS_QUERY_PARAM)) {
+        const pass = url.searchParams.get(import_farming_net_pass.PASS_QUERY_PARAM);
+        const passResult = this.farmingNetPassVerifier ? this.farmingNetPassVerifier.verify(pass) : { valid: false };
+        if (passResult.valid) {
+          this.setAuthenticatedCookie(res);
+          this.redirectWithoutQueryParameter(res, url, import_farming_net_pass.PASS_QUERY_PARAM);
+          return;
+        }
+        const cookieToken = this.extractCookieToken(req);
+        if (cookieToken && this.verify(cookieToken)) {
+          this.redirectWithoutQueryParameter(res, url, import_farming_net_pass.PASS_QUERY_PARAM);
+          return;
+        }
+      }
+      const token = this.extractToken(req);
+      if (url.searchParams.has("token")) {
+        if (token && this.verify(token)) {
+          this.setAuthenticatedCookie(res);
+          if (this.redirectQueryToken && ["GET", "HEAD"].includes(method)) {
+            this.redirectWithoutQueryParameter(res, url, "token");
+            return;
+          }
+          return next();
+        }
+      }
+      if (token && this.verify(token)) {
+        return next();
+      }
+      res.writeHead(401, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Token required. Use the URL printed in terminal." }));
+    };
+  }
+  verifyWebSocket(req) {
+    if (this.disabled) return true;
+    const token = this.extractToken(req);
+    return token !== null && this.verify(token);
+  }
+  cleanup(options = {}) {
+    if (options.removeTokenFile !== true) return;
+    try {
+      fs.unlinkSync(this.tokenFile);
+    } catch {
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TokenAuth,
+  decodeCookieToken,
+  encodeCookieToken,
+  generatePoeticToken,
+  getPoeticTokenEntropyBits
+});

package/backend/authoritative-inventory-cache.cjs

@@ -0,0 +1,383 @@
+// Generated by scripts/build-backend-runtime.ts. Do not edit.
+"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 authoritative_inventory_cache_exports = {};
+__export(authoritative_inventory_cache_exports, {
+  AuthoritativeInventoryCache: () => AuthoritativeInventoryCache,
+  filesystemFingerprint: () => filesystemFingerprint
+});
+module.exports = __toCommonJS(authoritative_inventory_cache_exports);
+var crypto = __toESM(require("crypto"));
+var fs = __toESM(require("fs"));
+var fsp = __toESM(require("fs/promises"));
+var path = __toESM(require("path"));
+const DEFAULT_IGNORED_NAMES = /* @__PURE__ */ new Set([".git", "node_modules"]);
+function normalizedWatchPaths(input) {
+  return [...new Set(input.map((candidate) => String(candidate || "").trim()).filter(Boolean).map((candidate) => path.resolve(candidate)))].sort((left, right) => left.localeCompare(right));
+}
+async function filesystemFingerprint(inputPaths, options = {}) {
+  const roots = normalizedWatchPaths(inputPaths);
+  const ignoredNames = options.ignoredNames || DEFAULT_IGNORED_NAMES;
+  const maxDepth = typeof options.maxDepth === "number" && Number.isFinite(options.maxDepth) ? Math.max(0, Math.floor(options.maxDepth)) : 16;
+  const maxEntries = typeof options.maxEntries === "number" && Number.isFinite(options.maxEntries) ? Math.max(1, Math.floor(options.maxEntries)) : 5e4;
+  const hash = crypto.createHash("sha256");
+  const appendOnlyRoots = normalizedWatchPaths(options.appendOnlyRoots || []);
+  const appendTolerantPaths = new Set(normalizedWatchPaths(options.appendTolerantPaths || []));
+  const appendOnlyPrefixBytes = typeof options.appendOnlyPrefixBytes === "number" ? Math.max(1, Math.floor(options.appendOnlyPrefixBytes)) : 64 * 1024;
+  let entries = 0;
+  const isAppendOnlyFile = (filePath) => filePath.endsWith(".jsonl") && appendOnlyRoots.some((root) => {
+    const relative = path.relative(root, filePath);
+    return relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+  });
+  const isAppendTolerantFile = (filePath) => isAppendOnlyFile(filePath) || appendTolerantPaths.has(path.resolve(filePath));
+  const visit = async (root, current, depth) => {
+    if (entries >= maxEntries) {
+      throw new Error(`Inventory fingerprint exceeded ${maxEntries} filesystem entries`);
+    }
+    entries += 1;
+    const relative = path.relative(root, current).split(path.sep).join("/") || ".";
+    let stat;
+    try {
+      stat = await fsp.lstat(current);
+    } catch (caught) {
+      const error = caught;
+      if (error?.code === "ENOENT" || error?.code === "ENOTDIR") {
+        hash.update(`missing\0${root}\0${relative}
+`);
+        return;
+      }
+      throw caught;
+    }
+    const kind = stat.isDirectory() ? "d" : stat.isFile() ? "f" : stat.isSymbolicLink() ? "l" : "o";
+    if (stat.isFile() && options.appendOnlyIdentityOnly && isAppendTolerantFile(current)) {
+      hash.update(`${kind}\0${root}\0${relative}\0${stat.dev}\0${stat.ino}\0append-tolerant
+`);
+      return;
+    }
+    if (stat.isFile() && isAppendOnlyFile(current)) {
+      const length = Math.min(stat.size, appendOnlyPrefixBytes);
+      const buffer = Buffer.alloc(length);
+      const handle = await fsp.open(current, "r");
+      try {
+        if (length > 0) await handle.read(buffer, 0, length, 0);
+      } finally {
+        await handle.close();
+      }
+      hash.update(`${kind}\0${root}\0${relative}\0${stat.dev}\0${stat.ino}\0prefix\0${length}
+`);
+      hash.update(buffer);
+      hash.update("\n");
+    } else {
+      hash.update(`${kind}\0${root}\0${relative}\0${stat.dev}\0${stat.ino}\0${stat.size}\0${stat.mtimeMs}
+`);
+    }
+    if (!stat.isDirectory() || depth >= maxDepth) return;
+    const children = await fsp.readdir(current, { withFileTypes: true });
+    children.sort((left, right) => left.name.localeCompare(right.name));
+    for (const child of children) {
+      if (ignoredNames.has(child.name)) continue;
+      await visit(root, path.join(current, child.name), depth + 1);
+    }
+  };
+  for (const root of roots) {
+    await visit(root, root, 0);
+  }
+  return hash.digest("hex");
+}
+class InventorySnapshotStore {
+  document = null;
+  filePath;
+  writeTask = Promise.resolve();
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+  load() {
+    if (this.document) return this.document;
+    try {
+      const parsed = JSON.parse(fs.readFileSync(this.filePath, "utf8"));
+      if (parsed?.version === 1 && parsed.entries && typeof parsed.entries === "object") {
+        this.document = parsed;
+        return parsed;
+      }
+    } catch {
+    }
+    this.document = { version: 1, entries: {} };
+    return this.document;
+  }
+  get(key) {
+    const snapshot = this.load().entries[key];
+    return snapshot && typeof snapshot.fingerprint === "string" ? snapshot : null;
+  }
+  set(key, snapshot) {
+    this.load().entries[key] = snapshot;
+    const serialized = JSON.stringify(this.document);
+    this.writeTask = this.writeTask.catch(() => {
+    }).then(async () => {
+      await fsp.mkdir(path.dirname(this.filePath), { recursive: true });
+      const temporary = `${this.filePath}.${process.pid}.${Date.now()}.${crypto.randomBytes(4).toString("hex")}.tmp`;
+      try {
+        await fsp.writeFile(temporary, serialized, { encoding: "utf8", mode: 384 });
+        await fsp.rename(temporary, this.filePath);
+      } finally {
+        await fsp.rm(temporary, { force: true }).catch(() => {
+        });
+      }
+    });
+    return this.writeTask;
+  }
+  deleteExcept(keys) {
+    const document = this.load();
+    let changed = false;
+    for (const key of Object.keys(document.entries)) {
+      if (keys.has(key)) continue;
+      delete document.entries[key];
+      changed = true;
+    }
+    if (!changed) return this.writeTask;
+    const serialized = JSON.stringify(document);
+    this.writeTask = this.writeTask.catch(() => {
+    }).then(async () => {
+      await fsp.mkdir(path.dirname(this.filePath), { recursive: true });
+      const temporary = `${this.filePath}.${process.pid}.${Date.now()}.${crypto.randomBytes(4).toString("hex")}.tmp`;
+      try {
+        await fsp.writeFile(temporary, serialized, { encoding: "utf8", mode: 384 });
+        await fsp.rename(temporary, this.filePath);
+      } finally {
+        await fsp.rm(temporary, { force: true }).catch(() => {
+        });
+      }
+    });
+    return this.writeTask;
+  }
+}
+let chokidarPromise = null;
+function loadChokidar() {
+  if (!chokidarPromise) chokidarPromise = import("chokidar");
+  return chokidarPromise;
+}
+class AuthoritativeInventoryCache {
+  entries = /* @__PURE__ */ new Map();
+  fingerprintOptions;
+  maxReconcileAttempts;
+  refreshDebounceMs;
+  snapshots;
+  constructor(options = {}) {
+    this.fingerprintOptions = options.fingerprintOptions || {};
+    this.maxReconcileAttempts = typeof options.maxReconcileAttempts === "number" ? Math.max(1, Math.floor(options.maxReconcileAttempts)) : 3;
+    this.refreshDebounceMs = typeof options.refreshDebounceMs === "number" ? Math.max(0, Math.floor(options.refreshDebounceMs)) : 150;
+    this.snapshots = options.snapshotFile ? new InventorySnapshotStore(options.snapshotFile) : null;
+  }
+  entry(key) {
+    let entry = this.entries.get(key);
+    if (entry) return entry;
+    const snapshot = this.snapshots?.get(key);
+    entry = {
+      key,
+      backgroundRefresh: true,
+      fingerprint: snapshot?.fingerprint || "",
+      fingerprintOptions: {},
+      fingerprintPaths: [],
+      generation: 0,
+      load: null,
+      pending: null,
+      refreshTimer: null,
+      sourceMayChangeDuringLoad: false,
+      value: snapshot?.value ?? null,
+      validate: null,
+      watchPaths: [],
+      watchSignature: "",
+      watcher: null,
+      watcherReady: null,
+      watcherToken: 0
+    };
+    this.entries.set(key, entry);
+    return entry;
+  }
+  markDirty(entry) {
+    entry.generation += 1;
+    entry.fingerprint = "";
+    if (!entry.backgroundRefresh || !entry.load || entry.refreshTimer) return;
+    entry.refreshTimer = setTimeout(() => {
+      entry.refreshTimer = null;
+      void this.resolveCurrent(entry).catch(() => {
+      });
+    }, this.refreshDebounceMs);
+    entry.refreshTimer.unref?.();
+  }
+  async configureWatcher(entry, watchPaths) {
+    const normalized = normalizedWatchPaths(watchPaths);
+    const signature = JSON.stringify(normalized);
+    if (entry.watchSignature === signature && entry.watcherReady) {
+      await entry.watcherReady;
+      return;
+    }
+    entry.watcherToken += 1;
+    const token = entry.watcherToken;
+    const hadWatchConfiguration = Boolean(entry.watchSignature);
+    entry.watchSignature = signature;
+    entry.watchPaths = normalized;
+    if (hadWatchConfiguration) this.markDirty(entry);
+    if (entry.watcher) await entry.watcher.close().catch(() => {
+    });
+    entry.watcher = null;
+    if (normalized.length === 0) {
+      entry.watcherReady = Promise.resolve();
+      return;
+    }
+    const chokidar = await loadChokidar();
+    const watcher = chokidar.watch(normalized, {
+      awaitWriteFinish: { pollInterval: 25, stabilityThreshold: 100 },
+      followSymlinks: false,
+      ignoreInitial: true,
+      persistent: true
+    });
+    entry.watcher = watcher;
+    entry.watcherReady = new Promise((resolve) => {
+      const onError = () => {
+        watcher.off("ready", onReady);
+        resolve();
+      };
+      const onReady = () => {
+        watcher.off("error", onError);
+        resolve();
+      };
+      watcher.once("error", onError);
+      watcher.once("ready", onReady);
+    });
+    watcher.on("all", (eventName, changedPath) => {
+      if (entry.watcherToken !== token) return;
+      if (eventName === "change" && changedPath.endsWith(".jsonl") && (entry.fingerprintOptions.appendOnlyRoots || []).some((root) => {
+        const relative = path.relative(root, changedPath);
+        return relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+      })) return;
+      this.markDirty(entry);
+    });
+    watcher.on("error", () => {
+      if (entry.watcherToken !== token) return;
+      this.markDirty(entry);
+    });
+    await entry.watcherReady;
+  }
+  async reconcile(entry) {
+    if (!entry.load) throw new Error(`Inventory loader is unavailable for ${entry.key}`);
+    for (let attempt = 0; attempt < this.maxReconcileAttempts; attempt += 1) {
+      const generation = entry.generation;
+      const fingerprintOptions = { ...this.fingerprintOptions, ...entry.fingerprintOptions };
+      const before = entry.sourceMayChangeDuringLoad ? "" : await filesystemFingerprint(entry.fingerprintPaths, fingerprintOptions);
+      const hasAppendTolerantSources = (fingerprintOptions.appendOnlyRoots || []).length > 0 || (fingerprintOptions.appendTolerantPaths || []).length > 0;
+      const stableBefore = !entry.sourceMayChangeDuringLoad && hasAppendTolerantSources ? await filesystemFingerprint(entry.fingerprintPaths, {
+        ...fingerprintOptions,
+        appendOnlyIdentityOnly: true
+      }) : before;
+      const value = await entry.load();
+      if (entry.validate && !entry.validate(value)) {
+        throw new Error(`Inventory loader returned an invalid value for ${entry.key}`);
+      }
+      const after = await filesystemFingerprint(entry.fingerprintPaths, fingerprintOptions);
+      const stableAfter = !entry.sourceMayChangeDuringLoad && hasAppendTolerantSources ? await filesystemFingerprint(entry.fingerprintPaths, {
+        ...fingerprintOptions,
+        appendOnlyIdentityOnly: true
+      }) : after;
+      if (!entry.sourceMayChangeDuringLoad && (generation !== entry.generation || stableBefore !== stableAfter)) continue;
+      entry.value = value;
+      entry.fingerprint = before === after ? after : "";
+      if (entry.fingerprint) {
+        await this.snapshots?.set(entry.key, { fingerprint: after, value });
+      }
+      return value;
+    }
+    throw new Error(`Inventory changed repeatedly while reconciling ${entry.key}`);
+  }
+  resolveCurrent(entry) {
+    if (entry.pending) return entry.pending;
+    entry.pending = (async () => {
+      if (entry.watcherReady) await entry.watcherReady;
+      const generation = entry.generation;
+      const fingerprint = await filesystemFingerprint(entry.fingerprintPaths, {
+        ...this.fingerprintOptions,
+        ...entry.fingerprintOptions
+      });
+      if (entry.value !== null && (!entry.validate || entry.validate(entry.value)) && entry.fingerprint === fingerprint && generation === entry.generation) {
+        return entry.value;
+      }
+      return this.reconcile(entry);
+    })().finally(() => {
+      entry.pending = null;
+    });
+    return entry.pending;
+  }
+  async get(key, request) {
+    const entry = this.entry(key);
+    entry.backgroundRefresh = request.backgroundRefresh !== false;
+    entry.load = request.load;
+    entry.validate = request.validate || null;
+    entry.fingerprintOptions = request.fingerprintOptions || {};
+    entry.sourceMayChangeDuringLoad = request.sourceMayChangeDuringLoad === true;
+    const fingerprintPaths = normalizedWatchPaths(request.fingerprintPaths || request.watchPaths);
+    if (JSON.stringify(entry.fingerprintPaths) !== JSON.stringify(fingerprintPaths)) {
+      if (entry.fingerprintPaths.length > 0) entry.fingerprint = "";
+      entry.fingerprintPaths = fingerprintPaths;
+    }
+    await this.configureWatcher(entry, request.watchPaths);
+    return this.resolveCurrent(entry);
+  }
+  invalidate(key) {
+    if (key !== void 0) {
+      const entry = this.entries.get(key);
+      if (entry) this.markDirty(entry);
+      return;
+    }
+    this.entries.forEach((entry) => this.markDirty(entry));
+  }
+  async retain(keys) {
+    const closes = [];
+    for (const [key, entry] of this.entries) {
+      if (keys.has(key)) continue;
+      this.entries.delete(key);
+      if (entry.refreshTimer) clearTimeout(entry.refreshTimer);
+      if (entry.watcher) closes.push(entry.watcher.close());
+    }
+    await Promise.allSettled(closes);
+    await this.snapshots?.deleteExcept(keys);
+  }
+  async close() {
+    const closes = [];
+    for (const entry of this.entries.values()) {
+      if (entry.refreshTimer) clearTimeout(entry.refreshTimer);
+      if (entry.watcher) closes.push(entry.watcher.close());
+    }
+    this.entries.clear();
+    await Promise.allSettled(closes);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuthoritativeInventoryCache,
+  filesystemFingerprint
+});