@farm.js/core 0.1.46 → 0.1.48

package/dist/chunk-AXRNEVCS.cjs

@@ -0,0 +1,150 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } async function _asyncOptionalChain(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 = await fn(value); } else if (op === 'call' || op === 'optionalCall') { value = await fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+var _chunkYQGZLCT4cjs = require('./chunk-YQGZLCT4.cjs');
+
+
+var _chunkMPU5DOXXcjs = require('./chunk-MPU5DOXX.cjs');
+
+
+var _chunkFGJQS4ECcjs = require('./chunk-FGJQS4EC.cjs');
+
+
+
+var _chunkDMAP4RNDcjs = require('./chunk-DMAP4RND.cjs');
+
+
+
+var _chunkDXUXQP2Tcjs = require('./chunk-DXUXQP2T.cjs');
+
+// src/server-query.ts
+var FARM_SERVER_QUERY_SYMBOL = /* @__PURE__ */ Symbol.for("farm.server-query");
+var requestInflight = /* @__PURE__ */ new WeakMap();
+var detachedInflight = /* @__PURE__ */ new Map();
+function createServerQuery(options) {
+  if (!options || typeof options.handler !== "function") {
+    throw new TypeError("createServerQuery requires a handler function");
+  }
+  if (typeof options.key !== "function") {
+    throw new TypeError("createServerQuery requires a key function");
+  }
+  const staleTime = normalizeServerQueryStaleTime(options.staleTime);
+  const execute = _chunkYQGZLCT4cjs.createServerFn.call(void 0, {
+    input: options.input,
+    middleware: options.middleware,
+    handler: async (context) => {
+      const routeKey = await options.key(context);
+      assertServerQueryKey(routeKey);
+      const clientKey = _chunkDXUXQP2Tcjs.createRouteDataCacheKey.call(void 0, routeKey);
+      const cacheKey = _chunkDXUXQP2Tcjs.createFarmCacheKey.call(void 0, ["route-data", routeKey]);
+      const producer = async () => {
+        const value = await options.handler(context);
+        return _chunkYQGZLCT4cjs._parseServerFnSchema.call(void 0, options.output, value, "output", "createServerQuery");
+      };
+      let data;
+      let updatedAt;
+      if (staleTime === 0) {
+        data = await dedupeServerQueryRequest(cacheKey, context.request, producer);
+        updatedAt = Date.now();
+      } else {
+        const cache = _chunkDMAP4RNDcjs.getFarmDataCache.call(void 0, );
+        data = await cache.getOrSet(cacheKey, producer, {
+          tags: [_chunkDMAP4RNDcjs.createRouteDataCacheTag.call(void 0, routeKey)],
+          revalidate: staleTime === false ? false : staleTime / 1e3
+        });
+        updatedAt = await _asyncNullishCoalesce(await _asyncOptionalChain([(await cache.getEntryAsync(cacheKey, { allowStale: true })), 'optionalAccess', async _ => _.createdAt]), async () => ( Date.now()));
+      }
+      return _chunkMPU5DOXXcjs.createFarmServerQueryResult.call(void 0, data, {
+        key: clientKey,
+        staleTime,
+        updatedAt,
+        ...options.persist === true ? { persist: true } : {}
+      });
+    }
+  });
+  const query = async (input) => {
+    const result = await execute(input);
+    return _chunkFGJQS4ECcjs.getServerActionExecutionContext.call(void 0, ) ? result : result.data;
+  };
+  Object.defineProperties(query, {
+    [FARM_SERVER_QUERY_SYMBOL]: {
+      value: true,
+      enumerable: false
+    },
+    __farmServerQuery: {
+      value: true,
+      enumerable: false
+    },
+    __farmServerQueryInput: {
+      value: options.input,
+      enumerable: false
+    },
+    __farmServerQueryOutput: {
+      value: options.output,
+      enumerable: false
+    }
+  });
+  _chunkYQGZLCT4cjs._attachServerFunctionDescriptor.call(void 0, 
+    query,
+    _chunkYQGZLCT4cjs.createServerFunctionDescriptor.call(void 0, "query", options, async (value) => {
+      const result = await _chunkYQGZLCT4cjs._runServerFunctionForCaller.call(void 0, 
+        execute,
+        value
+      );
+      return result.data;
+    })
+  );
+  return query;
+}
+async function dedupeServerQueryRequest(key, request, producer) {
+  let inflight;
+  if (request) {
+    inflight = _nullishCoalesce(requestInflight.get(request), () => ( /* @__PURE__ */ new Map()));
+    requestInflight.set(request, inflight);
+  } else {
+    inflight = detachedInflight;
+  }
+  const existing = inflight.get(key);
+  if (existing) return existing;
+  const promise = Promise.resolve().then(producer);
+  inflight.set(key, promise);
+  try {
+    return await promise;
+  } finally {
+    inflight.delete(key);
+  }
+}
+function normalizeServerQueryStaleTime(value) {
+  if (value === false) return false;
+  if (value === void 0) return 0;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || value < 0) {
+      throw new TypeError("createServerQuery staleTime must be a non-negative duration");
+    }
+    return value;
+  }
+  const match = value.match(/^(\d+(?:\.\d+)?)(ms|s|m|h)$/);
+  if (!match) {
+    throw new TypeError('createServerQuery staleTime must look like "250ms", "30s", "5m", or "1h"');
+  }
+  const amount = Number(match[1]);
+  const unit = match[2];
+  const multiplier = unit === "ms" ? 1 : unit === "s" ? 1e3 : unit === "m" ? 6e4 : 36e5;
+  return amount * multiplier;
+}
+function assertServerQueryKey(key) {
+  if (typeof key === "string") {
+    if (key.trim().length > 0) return;
+  } else if (Array.isArray(key)) {
+    return;
+  }
+  throw new TypeError("createServerQuery key must return a non-empty string or an array");
+}
+
+
+
+
+exports.FARM_SERVER_QUERY_SYMBOL = FARM_SERVER_QUERY_SYMBOL; exports.createServerQuery = createServerQuery;

package/dist/chunk-AY2YD5ZX.mjs

@@ -0,0 +1,34 @@
+// src/request-cookies.ts
+function parseRequestCookieHeader(header) {
+  if (!header?.trim()) return [];
+  return header.split(";").map((part) => part.trim()).filter(Boolean).map((part) => {
+    const separatorIndex = part.indexOf("=");
+    if (separatorIndex === -1) {
+      return {
+        name: decodeCookieName(part),
+        value: ""
+      };
+    }
+    return {
+      name: decodeCookieName(part.slice(0, separatorIndex).trim()),
+      value: decodeCookiePart(part.slice(separatorIndex + 1).trim())
+    };
+  }).filter((cookie) => cookie.name.length > 0);
+}
+var RESERVED_PREFIX = /^__(host|secure)-/i;
+function decodeCookieName(raw) {
+  const decoded = decodeCookiePart(raw);
+  return RESERVED_PREFIX.test(decoded) && !RESERVED_PREFIX.test(raw) ? raw : decoded;
+}
+function decodeCookiePart(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+
+export {
+  parseRequestCookieHeader,
+  decodeCookieName
+};

package/dist/chunk-AYP2YFVN.mjs

@@ -0,0 +1,168 @@
+// src/routing/specificity.ts
+var AmbiguousRouteError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AmbiguousRouteError";
+  }
+};
+var NonTerminalCatchAllRouteError = class extends TypeError {
+  constructor(message) {
+    super(message);
+    this.name = "NonTerminalCatchAllRouteError";
+  }
+};
+var DuplicateRouteParameterError = class extends AmbiguousRouteError {
+  constructor(message) {
+    super(message);
+    this.name = "DuplicateRouteParameterError";
+  }
+};
+var ReservedRouteParameterError = class extends AmbiguousRouteError {
+  constructor(message) {
+    super(message);
+    this.name = "ReservedRouteParameterError";
+  }
+};
+var BrowserUnstableRouteError = class extends TypeError {
+  constructor(message) {
+    super(message);
+    this.name = "BrowserUnstableRouteError";
+  }
+};
+var SEGMENT_RANK = {
+  static: 4,
+  dynamic: 3,
+  "catch-all": 1,
+  "optional-catch-all": 0
+};
+var ROUTE_END_RANK = 2;
+function compareRouteSpecificity(left, right) {
+  const length = Math.max(left.length, right.length);
+  for (let index = 0; index < length; index++) {
+    const leftRank = index < left.length ? SEGMENT_RANK[left[index]] : ROUTE_END_RANK;
+    const rightRank = index < right.length ? SEGMENT_RANK[right[index]] : ROUTE_END_RANK;
+    if (leftRank !== rightRank) return rightRank - leftRank;
+  }
+  return 0;
+}
+function compareRoutePatternSpecificity(left, right, syntax = "page") {
+  return compareRouteSpecificity(
+    getRoutePatternSpecificity(left, syntax),
+    getRoutePatternSpecificity(right, syntax)
+  );
+}
+var ROUTER_PARAMETER_NAME = "[A-Za-z0-9_$-]+";
+var PAGE_PARAMETER_PATTERN = /^(?:\[\[\.\.\.(.+)\]\]|\[\.\.\.(.+)\]|\[(.+)\])$/;
+var ROUTER_PARAMETER_PATTERN = /^(?:\[\[\.\.\.([A-Za-z0-9_$-]+)\]\]|\[\.\.\.([A-Za-z0-9_$-]+)\]|\[([A-Za-z0-9_$-]+)\]|:([A-Za-z0-9_$-]+)|\*([A-Za-z0-9_$-]+)\??)$/;
+var RESERVED_PARAMETER_NAMES = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function assertBrowserStableRoutePath(pattern) {
+  if (pattern.includes("\\") || hasControlCharacter(pattern)) {
+    throw new BrowserUnstableRouteError(
+      `Route path "${pattern}" cannot contain backslashes or control characters.`
+    );
+  }
+  for (const segment of pattern.split("/").filter(Boolean)) {
+    if (segment.startsWith("(") && segment.endsWith(")") || segment.startsWith("[") && segment.endsWith("]")) {
+      continue;
+    }
+    let decoded = segment;
+    try {
+      decoded = decodeURIComponent(segment);
+    } catch {
+    }
+    if (decoded === "." || decoded === ".." || decoded.includes("/") || decoded.includes("\\") || hasControlCharacter(decoded)) {
+      throw new BrowserUnstableRouteError(
+        `Route path "${pattern}" contains browser-unstable segment "${segment}".`
+      );
+    }
+  }
+}
+function hasControlCharacter(value) {
+  return Array.from(value).some((character) => {
+    const code = character.charCodeAt(0);
+    return code <= 31 || code >= 127 && code <= 159;
+  });
+}
+function assertUniqueRouteParameters(pattern, syntax = "page") {
+  const parameterPattern = syntax === "router" ? ROUTER_PARAMETER_PATTERN : PAGE_PARAMETER_PATTERN;
+  const names = /* @__PURE__ */ new Set();
+  for (const segment of splitRoutePattern(pattern, syntax)) {
+    const match = parameterPattern.exec(segment);
+    const name = match?.slice(1).find(Boolean);
+    if (!name) continue;
+    if (RESERVED_PARAMETER_NAMES.has(name)) {
+      throw new ReservedRouteParameterError(
+        `Route parameter "${name}" in route "${pattern}" is reserved. Use a different parameter name.`
+      );
+    }
+    if (names.has(name)) {
+      throw new DuplicateRouteParameterError(
+        `Duplicate route parameter "${name}" in route "${pattern}". Each dynamic segment must use a unique name.`
+      );
+    }
+    names.add(name);
+  }
+}
+function splitRoutePattern(pattern, syntax) {
+  return pattern.replace(/\\/g, "/").split("/").filter(Boolean).filter(
+    (segment) => syntax === "api" ? true : !(segment.startsWith("(") && segment.endsWith(")"))
+  );
+}
+function assertTerminalCatchAll(pattern, syntax = "page") {
+  const segments = splitRoutePattern(pattern, syntax);
+  const parameterName = syntax === "router" ? ROUTER_PARAMETER_NAME : ".+";
+  const catchAllPattern = new RegExp(
+    syntax === "router" ? `^(?:\\[\\[\\.\\.\\.${parameterName}\\]\\]|\\[\\.\\.\\.${parameterName}\\]|\\*${parameterName}\\??)$` : `^(?:\\[\\[\\.\\.\\.${parameterName}\\]\\]|\\[\\.\\.\\.${parameterName}\\])$`
+  );
+  const catchAllIndex = segments.findIndex((segment) => catchAllPattern.test(segment));
+  if (catchAllIndex >= 0 && catchAllIndex !== segments.length - 1) {
+    throw new NonTerminalCatchAllRouteError(
+      `Catch-all segment "${segments[catchAllIndex]}" must be the final segment in route "${pattern}".`
+    );
+  }
+}
+function getRoutePatternShape(pattern, syntax = "page") {
+  assertTerminalCatchAll(pattern, syntax);
+  const segments = splitRoutePattern(pattern, syntax).map((segment) => {
+    const specificity = getPatternSegmentSpecificity(segment, syntax);
+    if (specificity !== "static") return specificity;
+    try {
+      return `static:${decodeURIComponent(segment)}`;
+    } catch {
+      return `static:${segment}`;
+    }
+  });
+  return segments.length === 0 ? "/" : JSON.stringify(segments);
+}
+function getRoutePatternSpecificity(pattern, syntax = "page") {
+  assertTerminalCatchAll(pattern, syntax);
+  return splitRoutePattern(pattern, syntax).map(
+    (segment) => getPatternSegmentSpecificity(segment, syntax)
+  );
+}
+function getPatternSegmentSpecificity(segment, syntax) {
+  const parameterName = syntax === "router" ? ROUTER_PARAMETER_NAME : ".+";
+  const supportsColonAndStar = syntax === "router";
+  if (new RegExp(`^\\[\\[\\.\\.\\.${parameterName}\\]\\]$`).test(segment) || supportsColonAndStar && new RegExp(`^\\*${parameterName}\\?$`).test(segment)) {
+    return "optional-catch-all";
+  }
+  if (new RegExp(`^\\[\\.\\.\\.${parameterName}\\]$`).test(segment) || supportsColonAndStar && new RegExp(`^\\*${parameterName}$`).test(segment)) {
+    return "catch-all";
+  }
+  if (new RegExp(`^\\[${parameterName}\\]$`).test(segment) || supportsColonAndStar && new RegExp(`^:${parameterName}$`).test(segment)) {
+    return "dynamic";
+  }
+  return "static";
+}
+
+export {
+  AmbiguousRouteError,
+  NonTerminalCatchAllRouteError,
+  compareRouteSpecificity,
+  compareRoutePatternSpecificity,
+  assertBrowserStableRoutePath,
+  assertUniqueRouteParameters,
+  assertTerminalCatchAll,
+  getRoutePatternShape,
+  getRoutePatternSpecificity
+};

package/dist/chunk-AZQXXXDX.mjs

@@ -0,0 +1,80 @@
+// src/cache-invalidation.ts
+var FARM_CACHE_INVALIDATION_HEADER = "x-farm-cache-invalidations";
+var FARM_CACHE_INVALIDATION_STATE = /* @__PURE__ */ Symbol.for("farm.cacheInvalidationState");
+var globalState = globalThis;
+function getFarmCacheInvalidationState() {
+  return globalState[FARM_CACHE_INVALIDATION_STATE] ?? (globalState[FARM_CACHE_INVALIDATION_STATE] = {
+    listeners: /* @__PURE__ */ new Set(),
+    taskListeners: /* @__PURE__ */ new Set()
+  });
+}
+function warnFarmCacheListenerError(scope, error) {
+  const detail = error instanceof Error ? error.stack ?? error.message : String(error);
+  console.warn(`[farm:cache] ${scope} listener failed: ${detail}`);
+}
+function notifyFarmCacheInvalidation(key, source = "local") {
+  if (typeof key !== "string" || key.length === 0) return;
+  for (const listener of getFarmCacheInvalidationState().listeners) {
+    try {
+      listener(key, source);
+    } catch (error) {
+      warnFarmCacheListenerError("invalidation", error);
+    }
+  }
+}
+function notifyFarmCacheTask(task) {
+  for (const listener of getFarmCacheInvalidationState().taskListeners) {
+    try {
+      listener(task);
+    } catch (error) {
+      warnFarmCacheListenerError("task", error);
+    }
+  }
+}
+function applyFarmCacheInvalidations(keys, source = "local") {
+  if (!Array.isArray(keys)) return;
+  for (const key of keys) {
+    if (typeof key === "string") {
+      notifyFarmCacheInvalidation(key, source);
+    }
+  }
+}
+function encodeFarmCacheInvalidations(keys) {
+  const normalized = Array.from(
+    new Set(keys.filter((key) => typeof key === "string" && key.length > 0))
+  );
+  if (normalized.length === 0) return null;
+  return encodeURIComponent(JSON.stringify(normalized));
+}
+function decodeFarmCacheInvalidations(value) {
+  if (!value) return [];
+  try {
+    const parsed = JSON.parse(decodeURIComponent(value));
+    return Array.isArray(parsed) ? Array.from(
+      new Set(parsed.filter((key) => typeof key === "string" && key.length > 0))
+    ) : [];
+  } catch {
+    return [];
+  }
+}
+function subscribeFarmCacheInvalidation(listener) {
+  const state = getFarmCacheInvalidationState();
+  state.listeners.add(listener);
+  return () => state.listeners.delete(listener);
+}
+function subscribeFarmCacheTask(listener) {
+  const state = getFarmCacheInvalidationState();
+  state.taskListeners.add(listener);
+  return () => state.taskListeners.delete(listener);
+}
+
+export {
+  FARM_CACHE_INVALIDATION_HEADER,
+  notifyFarmCacheInvalidation,
+  notifyFarmCacheTask,
+  applyFarmCacheInvalidations,
+  encodeFarmCacheInvalidations,
+  decodeFarmCacheInvalidations,
+  subscribeFarmCacheInvalidation,
+  subscribeFarmCacheTask
+};

package/dist/chunk-B5BBTPJQ.cjs

@@ -0,0 +1,44 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+var _chunkIWFV5ZEDcjs = require('./chunk-IWFV5ZED.cjs');
+
+// src/api/server-path.ts
+function resolveFarmAPIServerBasePath(config) {
+  return config.baseURL.startsWith("/") ? config.basePath : _chunkIWFV5ZEDcjs.DEFAULT_FARM_API_BASE_PATH;
+}
+function resolveFarmAPICanonicalPathname(pathname, serverBasePath = _chunkIWFV5ZEDcjs.DEFAULT_FARM_API_BASE_PATH) {
+  const basePath = _chunkIWFV5ZEDcjs.normalizeFarmAPIBasePath.call(void 0, serverBasePath);
+  if (basePath === _chunkIWFV5ZEDcjs.DEFAULT_FARM_API_BASE_PATH) return pathname;
+  if (basePath === "/") {
+    return pathname === "/" ? _chunkIWFV5ZEDcjs.DEFAULT_FARM_API_BASE_PATH : `${_chunkIWFV5ZEDcjs.DEFAULT_FARM_API_BASE_PATH}${pathname.startsWith("/") ? pathname : `/${pathname}`}`;
+  }
+  if (pathname === basePath) return _chunkIWFV5ZEDcjs.DEFAULT_FARM_API_BASE_PATH;
+  if (pathname.startsWith(`${basePath}/`)) {
+    return `${_chunkIWFV5ZEDcjs.DEFAULT_FARM_API_BASE_PATH}${pathname.slice(basePath.length)}`;
+  }
+  return pathname;
+}
+function createFarmAPIMiddlewarePathnames(serverBasePath = _chunkIWFV5ZEDcjs.DEFAULT_FARM_API_BASE_PATH) {
+  const basePath = _chunkIWFV5ZEDcjs.normalizeFarmAPIBasePath.call(void 0, serverBasePath);
+  if (basePath === _chunkIWFV5ZEDcjs.DEFAULT_FARM_API_BASE_PATH) return (pathname) => [pathname];
+  const prefix = _chunkIWFV5ZEDcjs.DEFAULT_FARM_API_BASE_PATH;
+  return (pathname) => {
+    const canonical = resolveFarmAPICanonicalPathname(pathname, basePath);
+    if (canonical !== prefix && !canonical.startsWith(`${prefix}/`)) return [pathname];
+    const suffix = canonical.slice(prefix.length);
+    const publicPath = basePath === "/" ? suffix || "/" : `${basePath}${suffix}`;
+    return [.../* @__PURE__ */ new Set([pathname, canonical, publicPath])];
+  };
+}
+function resolveFarmAPIServerRoutePath(routePath, serverBasePath = _chunkIWFV5ZEDcjs.DEFAULT_FARM_API_BASE_PATH) {
+  return _chunkIWFV5ZEDcjs.resolveFarmAPIRequestURL.call(void 0, routePath, serverBasePath).pathname;
+}
+
+
+
+
+
+
+exports.resolveFarmAPIServerBasePath = resolveFarmAPIServerBasePath; exports.resolveFarmAPICanonicalPathname = resolveFarmAPICanonicalPathname; exports.createFarmAPIMiddlewarePathnames = createFarmAPIMiddlewarePathnames; exports.resolveFarmAPIServerRoutePath = resolveFarmAPIServerRoutePath;

package/dist/chunk-BBPDJGCU.cjs

@@ -0,0 +1,157 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkLNVGXUL3cjs = require('./chunk-LNVGXUL3.cjs');
+
+// src/i18n/catalog.ts
+var _promises = require('fs/promises');
+var _icumessageformatparser = require('@formatjs/icu-messageformat-parser');
+async function readFarmI18nCatalogs(config) {
+  if (!config.enabled) {
+    return { catalogs: {}, signatures: {} };
+  }
+  const catalogs = {};
+  for (const locale of config.locales) {
+    const filePath = _chunkLNVGXUL3cjs.resolveFarmI18nMessagePath.call(void 0, config, locale);
+    let source;
+    try {
+      source = await _promises.readFile.call(void 0, filePath, "utf8");
+    } catch (error) {
+      throw new Error(
+        `Unable to read Farm i18n catalog for "${locale}" at ${filePath}: ${messageOf(error)}`
+      );
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(source);
+    } catch (error) {
+      throw new Error(`Invalid JSON in Farm i18n catalog ${filePath}: ${messageOf(error)}`);
+    }
+    catalogs[locale] = flattenFarmI18nCatalog(parsed, filePath);
+  }
+  const reference = catalogs[config.defaultLocale] || {};
+  const signatures = {};
+  for (const [key, message] of Object.entries(reference)) {
+    signatures[key] = analyzeFarmI18nMessage(message, `${config.defaultLocale}:${key}`);
+  }
+  validateFarmI18nCatalogs(config, catalogs, signatures);
+  return { catalogs, signatures };
+}
+function flattenFarmI18nCatalog(input, source = "i18n catalog") {
+  if (!isPlainObject(input)) {
+    throw new Error(`${source} must contain a JSON object at its root.`);
+  }
+  const output = {};
+  const visit = (value, segments) => {
+    if (typeof value === "string") {
+      const key = segments.join(".");
+      if (!key) throw new Error(`${source} contains an empty message key.`);
+      if (Object.prototype.hasOwnProperty.call(output, key)) {
+        throw new Error(`${source} contains duplicate message key "${key}".`);
+      }
+      output[key] = value;
+      return;
+    }
+    if (!isPlainObject(value)) {
+      const key = segments.join(".") || "<root>";
+      throw new Error(`${source} message "${key}" must be a string or nested object.`);
+    }
+    for (const [key, nested] of Object.entries(value)) {
+      if (!key.trim()) throw new Error(`${source} contains an empty message key.`);
+      visit(nested, [...segments, key]);
+    }
+  };
+  visit(input, []);
+  return output;
+}
+function analyzeFarmI18nMessage(message, label = "message") {
+  let ast;
+  try {
+    ast = _icumessageformatparser.parse.call(void 0, message, { captureLocation: false });
+  } catch (error) {
+    throw new Error(`Invalid ICU syntax in ${label}: ${messageOf(error)}`);
+  }
+  const signature = {};
+  collectArguments(ast, signature, label);
+  return signature;
+}
+function validateFarmI18nCatalogs(config, catalogs, signatures) {
+  const referenceKeys = Object.keys(catalogs[config.defaultLocale] || {}).sort();
+  for (const locale of config.locales) {
+    const catalog = catalogs[locale] || {};
+    const localeKeys = Object.keys(catalog).sort();
+    const missing = referenceKeys.filter(
+      (key) => !Object.prototype.hasOwnProperty.call(catalog, key)
+    );
+    const extra = localeKeys.filter(
+      (key) => !Object.prototype.hasOwnProperty.call(signatures, key)
+    );
+    if (config.strict && (missing.length > 0 || extra.length > 0)) {
+      const details = [
+        missing.length ? `missing: ${missing.join(", ")}` : "",
+        extra.length ? `extra: ${extra.join(", ")}` : ""
+      ].filter(Boolean).join("; ");
+      throw new Error(
+        `Farm i18n catalog "${locale}" does not match the default catalog (${details}).`
+      );
+    }
+    for (const [key, message] of Object.entries(catalog)) {
+      const actual = analyzeFarmI18nMessage(message, `${locale}:${key}`);
+      const expected = signatures[key];
+      if (!expected || sameSignature(expected, actual)) continue;
+      throw new Error(
+        `Farm i18n message "${key}" in "${locale}" uses different variables than "${config.defaultLocale}".`
+      );
+    }
+  }
+}
+function collectArguments(elements, signature, label) {
+  for (const element of elements) {
+    switch (element.type) {
+      case _icumessageformatparser.TYPE.argument:
+        addArgument(signature, element.value, "string", label);
+        break;
+      case _icumessageformatparser.TYPE.number:
+      case _icumessageformatparser.TYPE.plural:
+        addArgument(signature, element.value, "number", label);
+        break;
+      case _icumessageformatparser.TYPE.date:
+      case _icumessageformatparser.TYPE.time:
+        addArgument(signature, element.value, "date", label);
+        break;
+      case _icumessageformatparser.TYPE.select:
+        addArgument(signature, element.value, "select", label);
+        break;
+      case _icumessageformatparser.TYPE.tag:
+        addArgument(signature, element.value, "rich", label);
+        collectArguments(element.children, signature, label);
+        break;
+    }
+    if (element.type === _icumessageformatparser.TYPE.plural || element.type === _icumessageformatparser.TYPE.select) {
+      for (const option of Object.values(element.options)) {
+        collectArguments(option.value, signature, label);
+      }
+    }
+  }
+}
+function addArgument(signature, name, kind, label) {
+  const existing = signature[name];
+  if (existing && existing !== kind) {
+    throw new Error(`Farm i18n ${label} uses variable "${name}" as both ${existing} and ${kind}.`);
+  }
+  signature[name] = kind;
+}
+function sameSignature(expected, actual) {
+  const expectedEntries = Object.entries(expected).sort(([a], [b]) => a.localeCompare(b));
+  const actualEntries = Object.entries(actual).sort(([a], [b]) => a.localeCompare(b));
+  return JSON.stringify(expectedEntries) === JSON.stringify(actualEntries);
+}
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+
+
+exports.readFarmI18nCatalogs = readFarmI18nCatalogs;