@farm.js/core 0.1.16 → 0.1.18

package/dist/chunk-EM6SBQKM.cjs

@@ -0,0 +1,470 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkNO3WWW3Ncjs = require('./chunk-NO3WWW3N.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/request-context.ts
+var REQUEST_CONTEXT_STORE_KEY = /* @__PURE__ */ Symbol.for("farm.requestContextStore");
+function getRequestContextStore() {
+  const globalState = globalThis;
+  if (!globalState[REQUEST_CONTEXT_STORE_KEY]) {
+    globalState[REQUEST_CONTEXT_STORE_KEY] = /* @__PURE__ */ new WeakMap();
+  }
+  return globalState[REQUEST_CONTEXT_STORE_KEY];
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getRequestContextStore, "getRequestContextStore");
+function getBucket(target) {
+  const requestContextStore = getRequestContextStore();
+  let bucket = requestContextStore.get(target);
+  if (!bucket) {
+    bucket = {
+      privateData: /* @__PURE__ */ new Map(),
+      exposedData: /* @__PURE__ */ new Map()
+    };
+    requestContextStore.set(target, bucket);
+  }
+  return bucket;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getBucket, "getBucket");
+function setRequestContext(target, key, value, options = {}) {
+  const bucket = getBucket(target);
+  bucket.privateData.set(key, value);
+  if (options.exposeToPage) {
+    bucket.exposedData.set(key, value);
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, setRequestContext, "setRequestContext");
+function getRequestContext(target, key) {
+  const requestContextStore = getRequestContextStore();
+  const bucket = requestContextStore.get(target);
+  return _optionalChain([bucket, 'optionalAccess', _ => _.privateData, 'access', _2 => _2.get, 'call', _3 => _3(key)]);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getRequestContext, "getRequestContext");
+function hasRequestContext(target, key) {
+  const requestContextStore = getRequestContextStore();
+  const bucket = requestContextStore.get(target);
+  return _nullishCoalesce(_optionalChain([bucket, 'optionalAccess', _4 => _4.privateData, 'access', _5 => _5.has, 'call', _6 => _6(key)]), () => ( false));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, hasRequestContext, "hasRequestContext");
+function deleteRequestContext(target, key) {
+  const requestContextStore = getRequestContextStore();
+  const bucket = requestContextStore.get(target);
+  if (!bucket) return false;
+  const removedPrivate = bucket.privateData.delete(key);
+  bucket.exposedData.delete(key);
+  return removedPrivate;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, deleteRequestContext, "deleteRequestContext");
+function clearRequestContext(target) {
+  const requestContextStore = getRequestContextStore();
+  const bucket = requestContextStore.get(target);
+  if (!bucket) return;
+  bucket.privateData.clear();
+  bucket.exposedData.clear();
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, clearRequestContext, "clearRequestContext");
+function getRequestContextSnapshot(target, options = {}) {
+  const requestContextStore = getRequestContextStore();
+  const bucket = requestContextStore.get(target);
+  if (!bucket) return /* @__PURE__ */ new Map();
+  if (options.exposedOnly) {
+    return new Map(bucket.exposedData);
+  }
+  return new Map(bucket.privateData);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getRequestContextSnapshot, "getRequestContextSnapshot");
+function copyRequestContext(source, target) {
+  const bucket = getRequestContextStore().get(source);
+  if (!bucket || source === target) return;
+  for (const [key, value] of bucket.privateData) {
+    setRequestContext(target, key, value, { exposeToPage: bucket.exposedData.has(key) });
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, copyRequestContext, "copyRequestContext");
+
+// src/server-http.ts
+function createFarmNodeRequestAbortSignal(req, res) {
+  const controller = new AbortController();
+  let disposed = false;
+  const dispose = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => {
+    if (disposed) return;
+    disposed = true;
+    req.off("aborted", abort);
+    res.off("close", abortOnEarlyClose);
+    res.off("finish", dispose);
+    controller.signal.removeEventListener("abort", dispose);
+  }, "dispose");
+  const abort = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => controller.abort(), "abort");
+  const abortOnEarlyClose = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => {
+    if (!res.writableEnded) abort();
+    dispose();
+  }, "abortOnEarlyClose");
+  if (req.aborted) {
+    controller.abort();
+    return controller.signal;
+  }
+  req.once("aborted", abort);
+  res.once("close", abortOnEarlyClose);
+  res.once("finish", dispose);
+  controller.signal.addEventListener("abort", dispose, { once: true });
+  return controller.signal;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createFarmNodeRequestAbortSignal, "createFarmNodeRequestAbortSignal");
+var DEFAULT_FARM_SERVER_BODY_SIZE_LIMIT = 1e7;
+var DEFAULT_FARM_SERVER_HEADERS_TIMEOUT = 6e4;
+var DEFAULT_FARM_SERVER_REQUEST_TIMEOUT = 3e5;
+var DEFAULT_FARM_SERVER_KEEP_ALIVE_TIMEOUT = 5e3;
+var DEFAULT_FARM_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT = 3e4;
+var MAX_FARM_SERVER_TIMEOUT = 2147483647;
+function matchesFarmIfNoneMatch(value, etag) {
+  const expected = parseEntityTag(trimOptionalWhitespace(etag));
+  if (!expected) return false;
+  const values = Array.isArray(value) ? value : [value];
+  const combined = values.filter((header) => typeof header === "string").join(",");
+  const fieldValue = trimOptionalWhitespace(combined);
+  if (!fieldValue) return false;
+  if (fieldValue === "*") return true;
+  let matched = false;
+  let hasEntityTag = false;
+  for (const candidate of splitEntityTags(fieldValue)) {
+    const token = trimOptionalWhitespace(candidate);
+    if (!token) continue;
+    const parsed = parseEntityTag(token);
+    if (!parsed) return false;
+    hasEntityTag = true;
+    if (parsed === expected) matched = true;
+  }
+  return hasEntityTag && matched;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, matchesFarmIfNoneMatch, "matchesFarmIfNoneMatch");
+function trimOptionalWhitespace(value) {
+  return value.replace(/^[\t ]+|[\t ]+$/g, "");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, trimOptionalWhitespace, "trimOptionalWhitespace");
+function parseEntityTag(value) {
+  const opaqueTag = value.startsWith("W/") ? value.slice(2) : value;
+  if (opaqueTag.length < 2 || opaqueTag[0] !== '"' || opaqueTag.at(-1) !== '"') return null;
+  for (let index = 1; index < opaqueTag.length - 1; index++) {
+    const code = opaqueTag.charCodeAt(index);
+    if (code === 33 || code >= 35 && code <= 126 || code >= 128) continue;
+    return null;
+  }
+  return opaqueTag;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, parseEntityTag, "parseEntityTag");
+function splitEntityTags(value) {
+  const tags = [];
+  let start = 0;
+  let quoted = false;
+  for (let index = 0; index < value.length; index++) {
+    const character = value[index];
+    if (character === '"') {
+      quoted = !quoted;
+    } else if (character === "," && !quoted) {
+      tags.push(value.slice(start, index));
+      start = index + 1;
+    }
+  }
+  tags.push(value.slice(start));
+  return tags;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, splitEntityTags, "splitEntityTags");
+var _FarmRequestBodyError = class _FarmRequestBodyError extends Error {
+  constructor(code, status, message) {
+    super(message);
+    this.name = "FarmRequestBodyError";
+    this.code = code;
+    this.status = status;
+  }
+};
+_chunkS3JO3N4Hcjs.__name.call(void 0, _FarmRequestBodyError, "FarmRequestBodyError");
+var FarmRequestBodyError = _FarmRequestBodyError;
+function resolveFarmServerConfig(config) {
+  const headersTimeout = parseFarmServerDuration(
+    _nullishCoalesce(_optionalChain([config, 'optionalAccess', _7 => _7.headersTimeout]), () => ( DEFAULT_FARM_SERVER_HEADERS_TIMEOUT)),
+    "server.headersTimeout"
+  );
+  const requestTimeout = parseFarmServerDuration(
+    _nullishCoalesce(_optionalChain([config, 'optionalAccess', _8 => _8.requestTimeout]), () => ( DEFAULT_FARM_SERVER_REQUEST_TIMEOUT)),
+    "server.requestTimeout"
+  );
+  if (headersTimeout > requestTimeout) {
+    throw new TypeError("server.headersTimeout must not exceed server.requestTimeout");
+  }
+  return Object.freeze({
+    bodySizeLimit: parseBodySizeLimit(
+      _nullishCoalesce(_optionalChain([config, 'optionalAccess', _9 => _9.bodySizeLimit]), () => ( DEFAULT_FARM_SERVER_BODY_SIZE_LIMIT)),
+      "server.bodySizeLimit"
+    ),
+    trustProxy: _optionalChain([config, 'optionalAccess', _10 => _10.trustProxy]) === true,
+    headersTimeout,
+    requestTimeout,
+    keepAliveTimeout: parseFarmServerDuration(
+      _nullishCoalesce(_optionalChain([config, 'optionalAccess', _11 => _11.keepAliveTimeout]), () => ( DEFAULT_FARM_SERVER_KEEP_ALIVE_TIMEOUT)),
+      "server.keepAliveTimeout"
+    ),
+    gracefulShutdownTimeout: parseFarmServerDuration(
+      _nullishCoalesce(_optionalChain([config, 'optionalAccess', _12 => _12.gracefulShutdownTimeout]), () => ( DEFAULT_FARM_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT)),
+      "server.gracefulShutdownTimeout"
+    ),
+    health: resolveFarmServerHealthConfig(_optionalChain([config, 'optionalAccess', _13 => _13.health]))
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveFarmServerConfig, "resolveFarmServerConfig");
+function parseFarmServerDuration(value, optionName = "duration") {
+  if (typeof value === "number") {
+    if (!Number.isSafeInteger(value) || value <= 0) {
+      throw new TypeError(`${optionName} must be a positive safe integer`);
+    }
+    if (value > MAX_FARM_SERVER_TIMEOUT) {
+      throw new TypeError(`${optionName} must not exceed ${MAX_FARM_SERVER_TIMEOUT} milliseconds`);
+    }
+    return value;
+  }
+  const match = value.trim().toLowerCase().match(/^(\d+(?:\.\d+)?)\s*(ms|s|m|h)$/);
+  if (!match) {
+    throw new TypeError(`${optionName} must be milliseconds or a duration such as "30s" or "2m"`);
+  }
+  const amount = Number(match[1]);
+  const unit = match[2];
+  const multiplier = unit === "ms" ? 1 : unit === "s" ? 1e3 : unit === "m" ? 6e4 : 36e5;
+  const milliseconds = Math.floor(amount * multiplier);
+  if (!Number.isSafeInteger(milliseconds) || milliseconds <= 0) {
+    throw new TypeError(`${optionName} must resolve to a positive safe integer`);
+  }
+  if (milliseconds > MAX_FARM_SERVER_TIMEOUT) {
+    throw new TypeError(`${optionName} must not exceed ${MAX_FARM_SERVER_TIMEOUT} milliseconds`);
+  }
+  return milliseconds;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, parseFarmServerDuration, "parseFarmServerDuration");
+function resolveFarmServerHealthConfig(config) {
+  if (config === false || config && "enabled" in config && config.enabled === false) {
+    return Object.freeze({
+      enabled: false,
+      livenessPath: "/_farm/health/live",
+      readinessPath: "/_farm/health/ready"
+    });
+  }
+  const livenessPath = normalizeHealthPath(
+    _nullishCoalesce(_optionalChain([config, 'optionalAccess', _14 => _14.livenessPath]), () => ( "/_farm/health/live")),
+    "server.health.livenessPath"
+  );
+  const readinessPath = normalizeHealthPath(
+    _nullishCoalesce(_optionalChain([config, 'optionalAccess', _15 => _15.readinessPath]), () => ( "/_farm/health/ready")),
+    "server.health.readinessPath"
+  );
+  if (livenessPath === readinessPath) {
+    throw new TypeError("server.health livenessPath and readinessPath must be different");
+  }
+  return Object.freeze({ enabled: true, livenessPath, readinessPath });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveFarmServerHealthConfig, "resolveFarmServerHealthConfig");
+function normalizeHealthPath(value, optionName) {
+  const path = value.trim();
+  if (!path.startsWith("/") || path.includes("?") || path.includes("#") || path.includes("*")) {
+    throw new TypeError(`${optionName} must be an absolute pathname without a query or wildcard`);
+  }
+  const normalized = path.length > 1 ? path.replace(/\/+$/, "") || "/" : path;
+  _chunkNO3WWW3Ncjs.assertBrowserStableRoutePath.call(void 0, normalized);
+  return normalized;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeHealthPath, "normalizeHealthPath");
+function parseBodySizeLimit(value, optionName = "bodySizeLimit") {
+  if (typeof value === "number") {
+    if (!Number.isSafeInteger(value) || value <= 0) {
+      throw new TypeError(`${optionName} must be a positive safe integer`);
+    }
+    return value;
+  }
+  const match = value.trim().toLowerCase().match(/^(\d+(?:\.\d+)?)\s*(b|kb|mb|gb|kib|mib|gib)?$/);
+  if (!match) {
+    throw new TypeError(`${optionName} must be bytes or a size string such as "500kb" or "10mb"`);
+  }
+  const amount = Number(match[1]);
+  const unit = _nullishCoalesce(match[2], () => ( "b"));
+  const multiplier = {
+    b: 1,
+    kb: 1e3,
+    mb: 1e6,
+    gb: 1e9,
+    kib: 1024,
+    mib: 1048576,
+    gib: 1073741824
+  };
+  const bytes = Math.floor(amount * multiplier[unit]);
+  if (!Number.isSafeInteger(bytes) || bytes <= 0) {
+    throw new TypeError(`${optionName} must resolve to a positive safe integer`);
+  }
+  return bytes;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, parseBodySizeLimit, "parseBodySizeLimit");
+function cloneFarmRequestWithContext(request) {
+  const cloned = request.clone();
+  copyRequestContext(request, cloned);
+  return cloned;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, cloneFarmRequestWithContext, "cloneFarmRequestWithContext");
+async function bufferFarmRequestBody(request, limit) {
+  if (request.method === "GET" || request.method === "HEAD" || request.body === null) {
+    return request;
+  }
+  const bytes = await readFarmRequestBody(request, limit);
+  const body = new Uint8Array(bytes.byteLength);
+  body.set(bytes);
+  const buffered = new Request(request, {
+    // oxlint-disable-next-line unicorn/no-invalid-fetch-options -- GET and HEAD return above.
+    body: body.buffer
+  });
+  copyRequestContext(request, buffered);
+  return buffered;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, bufferFarmRequestBody, "bufferFarmRequestBody");
+async function readFarmRequestBody(request, limit) {
+  try {
+    validateContentLength(request.headers.get("content-length"), limit);
+  } catch (error) {
+    void _optionalChain([request, 'access', _16 => _16.body, 'optionalAccess', _17 => _17.cancel, 'call', _18 => _18(error), 'access', _19 => _19.catch, 'call', _20 => _20(() => {
+    })]);
+    throw error;
+  }
+  throwIfAborted(request.signal);
+  if (!request.body) return new Uint8Array();
+  const reader = request.body.getReader();
+  const chunks = [];
+  let total = 0;
+  const cancelBodyRead = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => {
+    void reader.cancel(request.signal.reason).catch(() => {
+    });
+  }, "cancelBodyRead");
+  request.signal.addEventListener("abort", cancelBodyRead, { once: true });
+  try {
+    while (true) {
+      throwIfAborted(request.signal);
+      const { done, value } = await reader.read();
+      throwIfAborted(request.signal);
+      if (done) break;
+      if (!value) continue;
+      total += value.byteLength;
+      if (total > limit) {
+        const error = new FarmRequestBodyError("BODY_TOO_LARGE", 413, "Request body is too large");
+        void reader.cancel(error).catch(() => {
+        });
+        throw error;
+      }
+      chunks.push(value);
+    }
+  } catch (error) {
+    if (request.signal.aborted) throwIfAborted(request.signal);
+    throw error;
+  } finally {
+    request.signal.removeEventListener("abort", cancelBodyRead);
+    reader.releaseLock();
+  }
+  const body = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    body.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return body;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, readFarmRequestBody, "readFarmRequestBody");
+async function readNodeRequestBody(request, limit) {
+  const rawContentLength = request.headers["content-length"];
+  const contentLength = Array.isArray(rawContentLength) ? rawContentLength[0] : rawContentLength;
+  try {
+    validateContentLength(contentLength, limit);
+  } catch (error) {
+    _optionalChain([request, 'access', _21 => _21.resume, 'optionalCall', _22 => _22()]);
+    throw error;
+  }
+  return await new Promise((resolve, reject) => {
+    const chunks = [];
+    let total = 0;
+    let settled = false;
+    const cleanup = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => {
+      _optionalChain([request, 'access', _23 => _23.removeListener, 'optionalCall', _24 => _24("data", onData)]);
+      _optionalChain([request, 'access', _25 => _25.removeListener, 'optionalCall', _26 => _26("end", onEnd)]);
+      _optionalChain([request, 'access', _27 => _27.removeListener, 'optionalCall', _28 => _28("error", onError)]);
+    }, "cleanup");
+    const rejectOnce = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (error) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      _optionalChain([request, 'access', _29 => _29.resume, 'optionalCall', _30 => _30()]);
+      reject(error);
+    }, "rejectOnce");
+    const onData = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (chunk) => {
+      const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      total += bytes.byteLength;
+      if (total > limit) {
+        rejectOnce(new FarmRequestBodyError("BODY_TOO_LARGE", 413, "Request body is too large"));
+        return;
+      }
+      chunks.push(bytes);
+    }, "onData");
+    const onEnd = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      resolve(Buffer.concat(chunks, total));
+    }, "onEnd");
+    const onError = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (error) => rejectOnce(error), "onError");
+    request.on("data", onData);
+    request.on("end", onEnd);
+    request.on("error", onError);
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, readNodeRequestBody, "readNodeRequestBody");
+function createFarmRequestBodyErrorResponse(error) {
+  if (!(error instanceof FarmRequestBodyError)) return null;
+  return new Response(error.status === 413 ? "Payload Too Large" : "Bad Request", {
+    status: error.status,
+    headers: {
+      "cache-control": "no-store",
+      "content-type": "text/plain; charset=utf-8",
+      "x-content-type-options": "nosniff"
+    }
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createFarmRequestBodyErrorResponse, "createFarmRequestBodyErrorResponse");
+function validateContentLength(value, limit) {
+  const contentLength = _optionalChain([value, 'optionalAccess', _31 => _31.trim, 'call', _32 => _32()]);
+  if (!contentLength) return;
+  if (!/^\d+$/.test(contentLength)) {
+    throw new FarmRequestBodyError("INVALID_CONTENT_LENGTH", 400, "Invalid content-length header");
+  }
+  if (Number(contentLength) > limit) {
+    throw new FarmRequestBodyError("BODY_TOO_LARGE", 413, "Request body is too large");
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, validateContentLength, "validateContentLength");
+function throwIfAborted(signal) {
+  if (!signal.aborted) return;
+  if (signal.reason !== void 0) throw signal.reason;
+  throw new DOMException("The operation was aborted", "AbortError");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, throwIfAborted, "throwIfAborted");
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.setRequestContext = setRequestContext; exports.getRequestContext = getRequestContext; exports.hasRequestContext = hasRequestContext; exports.deleteRequestContext = deleteRequestContext; exports.clearRequestContext = clearRequestContext; exports.getRequestContextSnapshot = getRequestContextSnapshot; exports.copyRequestContext = copyRequestContext; exports.createFarmNodeRequestAbortSignal = createFarmNodeRequestAbortSignal; exports.DEFAULT_FARM_SERVER_BODY_SIZE_LIMIT = DEFAULT_FARM_SERVER_BODY_SIZE_LIMIT; exports.matchesFarmIfNoneMatch = matchesFarmIfNoneMatch; exports.resolveFarmServerConfig = resolveFarmServerConfig; exports.parseBodySizeLimit = parseBodySizeLimit; exports.cloneFarmRequestWithContext = cloneFarmRequestWithContext; exports.bufferFarmRequestBody = bufferFarmRequestBody; exports.readFarmRequestBody = readFarmRequestBody; exports.readNodeRequestBody = readNodeRequestBody; exports.createFarmRequestBodyErrorResponse = createFarmRequestBodyErrorResponse;

package/dist/{chunk-27JNCYEK.mjs → chunk-EN7WTEAY.mjs}

@@ -26,13 +26,13 @@ import {
 } from "./chunk-OLYK7EAK.mjs";
 import {
   discoverProgrammaticRoutePaths
-} from "./chunk-VO5SCWF5.mjs";
+} from "./chunk-BNGS6KJ6.mjs";
 import {
   readFarmI18nCatalogs
 } from "./chunk-FV45CKBC.mjs";
 import {
   resolvePluginRoutes
-} from "./chunk-OWTIOHON.mjs";
+} from "./chunk-SYGGPS4A.mjs";
 import {
   parseRoutePath
 } from "./chunk-KI3MESHB.mjs";

package/dist/{chunk-IGO2HEV7.mjs → chunk-F6SJAKFJ.mjs}

@@ -184,6 +184,8 @@ var _FarmDataCache = class _FarmDataCache {
   constructor(config = {}) {
     this.entries = /* @__PURE__ */ new Map();
     this.inflight = /* @__PURE__ */ new Map();
+    /** Local entries by tag, so tag counts and pruning never scan unrelated entries. */
+    this.entriesByTag = /* @__PURE__ */ new Map();
     this.invalidatedTagVersions = /* @__PURE__ */ new Map();
     this.activeGenerations = /* @__PURE__ */ new Set();
     this.version = 0;
@@ -202,6 +204,7 @@ var _FarmDataCache = class _FarmDataCache {
   configure(config = {}) {
     this.generation++;
     this.entries.clear();
+    this.entriesByTag.clear();
     this.inflight.clear();
     this.invalidatedTagVersions.clear();
     this.activeGenerations.clear();
@@ -368,14 +371,12 @@ var _FarmDataCache = class _FarmDataCache {
     return entry;
   }
   delete(key) {
-    const deleted = this.entries.delete(key);
-    if (deleted) this.pruneInvalidatedTagVersions();
+    const deleted = this.deleteLocalEntry(key);
     emitFarmEvent({ type: "cache.delete", key, deleted });
     return deleted;
   }
   async deleteAsync(key) {
-    const deleted = this.entries.delete(key);
-    if (deleted) this.pruneInvalidatedTagVersions();
+    const deleted = this.deleteLocalEntry(key);
     if (this.adapter) {
       await this.adapter.delete(this.createAdapterKey(key));
     }
@@ -386,6 +387,7 @@ var _FarmDataCache = class _FarmDataCache {
     const count = this.entries.size;
     this.generation++;
     this.entries.clear();
+    this.entriesByTag.clear();
     this.inflight.clear();
     this.invalidatedTagVersions.clear();
     this.activeGenerations.clear();
@@ -471,23 +473,32 @@ var _FarmDataCache = class _FarmDataCache {
       return cached.value;
     }
     const inflight = this.inflight.get(key);
-    if (inflight) {
+    if (inflight && !this.wasInvalidatedSince(inflight.tags, inflight.startVersion)) {
       emitFarmEvent({ type: "cache.dedupe", key });
-      return inflight;
+      return inflight.promise;
     }
     const tags = Array.from(normalizeCacheOptionsTags(options));
     const generation = this.generation;
+    const startVersion = this.version;
     const promise = this.fillCacheEntry(key, producer, options, tags, generation).catch((error) => {
       emitFarmEvent({ type: "cache.error", key, operation: "set", error });
       throw error;
     }).finally(() => {
-      if (this.inflight.get(key) === promise) {
+      if (this.inflight.get(key)?.promise === promise) {
         this.inflight.delete(key);
       }
     });
-    this.inflight.set(key, promise);
+    this.inflight.set(key, { promise, tags, startVersion });
     return promise;
   }
+  /** A fill that started before one of its tags was invalidated cannot satisfy later readers. */
+  wasInvalidatedSince(tags, version) {
+    for (const tag of tags) {
+      const invalidatedVersion = this.invalidatedTagVersions.get(tag);
+      if (invalidatedVersion !== void 0 && invalidatedVersion > version) return true;
+    }
+    return false;
+  }
   async fillCacheEntry(key, producer, options, tags, generation) {
     const adapter = this.adapter;
     const namespace = this.namespace;
@@ -528,7 +539,7 @@ var _FarmDataCache = class _FarmDataCache {
       return value;
     } finally {
       this.activeGenerations.delete(activeGeneration);
-      this.pruneInvalidatedTagVersions();
+      this.pruneInvalidatedTagVersions(activeGeneration.tags);
       if (leaseToken && adapter?.releaseLease) {
         try {
           await adapter.releaseLease(leaseKey, leaseToken);
@@ -573,18 +584,9 @@ var _FarmDataCache = class _FarmDataCache {
     }
     return void 0;
   }
-  countEntriesForTag(tag) {
-    let count = 0;
-    for (const entry of this.entries.values()) {
-      if (entry.tags.has(tag)) {
-        count++;
-      }
-    }
-    return count;
-  }
   countEntriesForTags(tags) {
     let count = 0;
-    for (const entry of this.entries.values()) {
+    for (const entry of this.entriesByTag.get(tags[0]) ?? []) {
       if (tags.every((tag) => entry.tags.has(tag))) {
         count++;
       }
@@ -592,10 +594,10 @@ var _FarmDataCache = class _FarmDataCache {
     return count;
   }
   invalidateTag(normalizedTag) {
-    const count = this.countEntriesForTag(normalizedTag);
+    const count = this.entriesByTag.get(normalizedTag)?.size ?? 0;
     this.invalidatedTagVersions.delete(normalizedTag);
     this.invalidatedTagVersions.set(normalizedTag, ++this.version);
-    this.pruneInvalidatedTagVersions();
+    this.pruneInvalidatedTagVersions([normalizedTag]);
     return count;
   }
   toPublicEntry(entry) {
@@ -625,19 +627,51 @@ var _FarmDataCache = class _FarmDataCache {
     this.entries.set(key, entry);
   }
   storeLocalEntry(entry) {
-    this.entries.delete(entry.key);
+    const removed = [];
+    const replaced = this.detachLocalEntry(entry.key);
+    if (replaced) removed.push(replaced);
     this.entries.set(entry.key, entry);
+    for (const tag of entry.tags) {
+      let tagged = this.entriesByTag.get(tag);
+      if (!tagged) this.entriesByTag.set(tag, tagged = /* @__PURE__ */ new Set());
+      tagged.add(entry);
+    }
     while (this.entries.size > this.maxEntries) {
       const oldestKey = this.entries.keys().next().value;
       if (oldestKey === void 0) break;
-      this.entries.delete(oldestKey);
+      removed.push(this.detachLocalEntry(oldestKey));
     }
-    this.pruneInvalidatedTagVersions();
+    for (const removedEntry of removed) this.pruneInvalidatedTagVersions(removedEntry.tags);
+  }
+  deleteLocalEntry(key) {
+    const entry = this.detachLocalEntry(key);
+    if (!entry) return false;
+    this.pruneInvalidatedTagVersions(entry.tags);
+    return true;
+  }
+  detachLocalEntry(key) {
+    const entry = this.entries.get(key);
+    if (!entry) return void 0;
+    this.entries.delete(key);
+    for (const tag of entry.tags) {
+      const tagged = this.entriesByTag.get(tag);
+      if (!tagged) continue;
+      tagged.delete(entry);
+      if (tagged.size === 0) this.entriesByTag.delete(tag);
+    }
+    return entry;
   }
-  pruneInvalidatedTagVersions() {
-    tags: for (const [tag, invalidatedVersion] of this.invalidatedTagVersions) {
-      for (const entry of this.entries.values()) {
-        if (entry.tags.has(tag) && entry.createdVersion < invalidatedVersion) continue tags;
+  /**
+   * Drop invalidation versions that no local entry or active fill can be stale against.
+   * Callers pass only the tags whose dependents just changed, so the cost is bounded by
+   * the entries sharing those tags rather than by the whole cache.
+   */
+  pruneInvalidatedTagVersions(tags) {
+    tags: for (const tag of tags) {
+      const invalidatedVersion = this.invalidatedTagVersions.get(tag);
+      if (invalidatedVersion === void 0) continue;
+      for (const entry of this.entriesByTag.get(tag) ?? []) {
+        if (entry.createdVersion < invalidatedVersion) continue tags;
       }
       for (const generation of this.activeGenerations) {
         if (generation.tags.has(tag) && generation.createdVersion < invalidatedVersion)

package/dist/{chunk-GSDIZACQ.mjs → chunk-FG5H2VCJ.mjs}

@@ -2,10 +2,10 @@ import {
   attachRevalidationListeners,
   createServerQueryCallKey,
   fetchServerQuery
-} from "./chunk-76MNRHTS.mjs";
+} from "./chunk-UUYF3CHN.mjs";
 import {
   getFarmClientDataCache
-} from "./chunk-HKLRP3BN.mjs";
+} from "./chunk-5SPPCN5J.mjs";
 import {
   __name
 } from "./chunk-LPEX4YW6.mjs";