@farm.js/core 0.1.17 → 0.1.19

package/dist/chunk-I7PUUDGY.cjs

@@ -0,0 +1,389 @@
+"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 _chunkH6G5INWMcjs = require('./chunk-H6G5INWM.cjs');
+
+
+var _chunkZEG3OPIBcjs = require('./chunk-ZEG3OPIB.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/client-cache.ts
+var invalidationTrackers = /* @__PURE__ */ new WeakMap();
+function trackFarmClientCacheInvalidations(cache) {
+  let trackers = invalidationTrackers.get(cache);
+  if (!trackers) {
+    trackers = /* @__PURE__ */ new Set();
+    invalidationTrackers.set(cache, trackers);
+  }
+  const keys = /* @__PURE__ */ new Set();
+  trackers.add(keys);
+  return {
+    has(key) {
+      const resolved = cache.resolveKey(key);
+      for (const invalidated of keys) {
+        if (cache.resolveKey(invalidated) === resolved) return true;
+      }
+      return false;
+    },
+    dispose() {
+      if (!trackers.delete(keys)) return;
+      keys.clear();
+      if (trackers.size === 0) invalidationTrackers.delete(cache);
+    }
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, trackFarmClientCacheInvalidations, "trackFarmClientCacheInvalidations");
+var cacheFinalizer = typeof FinalizationRegistry === "function" ? new FinalizationRegistry((unsubscribe) => unsubscribe()) : void 0;
+var DEFAULT_GC_SWEEP_INTERVAL_MS = 3e4;
+var _FarmClientDataCache = class _FarmClientDataCache {
+  constructor(options = {}) {
+    this.entries = /* @__PURE__ */ new Map();
+    this.aliases = /* @__PURE__ */ new Map();
+    this.aliasesByTarget = /* @__PURE__ */ new Map();
+    this.invalidatedAt = /* @__PURE__ */ new Map();
+    this.listeners = /* @__PURE__ */ new Map();
+    this.inflight = /* @__PURE__ */ new Map();
+    this.pendingMetadataSweeps = /* @__PURE__ */ new Set();
+    this.gcSweepIntervalMs = _nullishCoalesce(options.gcSweepIntervalMs, () => ( DEFAULT_GC_SWEEP_INTERVAL_MS));
+    if (options.subscribeToInvalidation !== false) {
+      if (typeof WeakRef === "function") {
+        const reference = new WeakRef(this);
+        const unsubscribe = _FarmClientDataCache.subscribeWeakCache(reference);
+        _optionalChain([cacheFinalizer, 'optionalAccess', _ => _.register, 'call', _2 => _2(this, unsubscribe, reference)]);
+        this.unsubscribeInvalidation = unsubscribe;
+      } else {
+        this.unsubscribeInvalidation = _chunkZEG3OPIBcjs.subscribeFarmCacheInvalidation.call(void 0, 
+          (key) => this.applyInvalidation(key, Date.now(), false)
+        );
+      }
+    }
+  }
+  // This closure must only capture a weak reference, never the cache itself.
+  static subscribeWeakCache(reference) {
+    const unsubscribe = _chunkZEG3OPIBcjs.subscribeFarmCacheInvalidation.call(void 0, (key) => {
+      const cache = reference.deref();
+      if (cache) cache.applyInvalidation(key, Date.now(), false);
+      else dispose();
+    });
+    function dispose() {
+      unsubscribe();
+      _optionalChain([cacheFinalizer, 'optionalAccess', _3 => _3.unregister, 'call', _4 => _4(reference)]);
+    }
+    _chunkS3JO3N4Hcjs.__name.call(void 0, dispose, "dispose");
+    return dispose;
+  }
+  get size() {
+    return this.entries.size;
+  }
+  /** @internal Attach or detach the persistence engine's observation sink. */
+  attachPersistence(sink) {
+    this.persistence = sink;
+  }
+  resolveKey(key) {
+    let resolved = key;
+    const seen = /* @__PURE__ */ new Set();
+    while (this.aliases.has(resolved) && !seen.has(resolved)) {
+      seen.add(resolved);
+      resolved = this.aliases.get(resolved);
+    }
+    return resolved;
+  }
+  get(key, now = Date.now()) {
+    const resolved = this.resolveKey(key);
+    const entry = this.entries.get(resolved);
+    if (!entry) return void 0;
+    if (entry.gcAt !== void 0 && now >= entry.gcAt) {
+      if (entry.fetching) return void 0;
+      this.entries.delete(resolved);
+      _optionalChain([this, 'access', _5 => _5.persistence, 'optionalAccess', _6 => _6.onDelete, 'call', _7 => _7(resolved)]);
+      this.sweepEntryMetadata(/* @__PURE__ */ new Set([resolved]));
+      this.emit(resolved);
+      return void 0;
+    }
+    return entry;
+  }
+  set(key, entry) {
+    const resolved = this.resolveKey(key);
+    const invalidatedAt = this.invalidatedAt.get(resolved);
+    const nextEntry = invalidatedAt !== void 0 && invalidatedAt > entry.updatedAt ? { ...entry, staleAt: 0, invalidatedAt } : { ...entry, invalidatedAt: void 0 };
+    if (invalidatedAt === void 0 || entry.updatedAt >= invalidatedAt) {
+      this.invalidatedAt.delete(resolved);
+    }
+    this.entries.set(resolved, nextEntry);
+    this.pendingMetadataSweeps.delete(resolved);
+    if (nextEntry.gcAt !== void 0) this.scheduleGcSweep();
+    _optionalChain([this, 'access', _8 => _8.persistence, 'optionalAccess', _9 => _9.onSet, 'call', _10 => _10(resolved, nextEntry)]);
+    this.emit(resolved);
+    return this;
+  }
+  delete(key) {
+    const resolved = this.resolveKey(key);
+    const deleted = this.entries.delete(resolved);
+    this.inflight.delete(resolved);
+    if (deleted) _optionalChain([this, 'access', _11 => _11.persistence, 'optionalAccess', _12 => _12.onDelete, 'call', _13 => _13(resolved)]);
+    if (deleted || this.pendingMetadataSweeps.has(resolved)) {
+      this.sweepEntryMetadata(/* @__PURE__ */ new Set([resolved]));
+    }
+    this.emit(resolved);
+    return deleted;
+  }
+  clear() {
+    const keys = /* @__PURE__ */ new Set([...this.entries.keys(), ...this.listeners.keys()]);
+    this.entries.clear();
+    this.aliases.clear();
+    this.aliasesByTarget.clear();
+    this.invalidatedAt.clear();
+    this.inflight.clear();
+    this.pendingMetadataSweeps.clear();
+    _optionalChain([this, 'access', _14 => _14.persistence, 'optionalAccess', _15 => _15.onClear, 'call', _16 => _16()]);
+    for (const key of keys) this.emit(key);
+  }
+  dispose() {
+    _optionalChain([this, 'access', _17 => _17.unsubscribeInvalidation, 'optionalCall', _18 => _18()]);
+    this.unsubscribeInvalidation = void 0;
+    if (this.gcTimer !== void 0) {
+      clearTimeout(this.gcTimer);
+      this.gcTimer = void 0;
+    }
+    this.clear();
+  }
+  isStale(key, now = Date.now()) {
+    const entry = this.get(key, now);
+    return !entry || entry.invalidatedAt !== void 0 || now >= entry.staleAt;
+  }
+  invalidate(key, now = Date.now()) {
+    this.applyInvalidation(key, now, true);
+  }
+  applyInvalidation(key, now, retainUnowned) {
+    const resolved = this.resolveKey(key);
+    for (const keys of _nullishCoalesce(invalidationTrackers.get(this), () => ( []))) keys.add(resolved);
+    const entry = this.entries.get(resolved);
+    const alreadyRetained = this.invalidatedAt.has(resolved);
+    if (retainUnowned || entry || alreadyRetained || this.hasMetadataOwner(resolved)) {
+      this.invalidatedAt.set(resolved, now);
+      if (!entry && !retainUnowned && !alreadyRetained) this.pendingMetadataSweeps.add(resolved);
+    }
+    if (entry) {
+      this.entries.set(resolved, {
+        ...entry,
+        staleAt: 0,
+        invalidatedAt: now
+      });
+    }
+    this.emit(resolved, "invalidate");
+  }
+  hasMetadataOwner(key) {
+    const related = /* @__PURE__ */ new Set([key]);
+    for (const target of related) {
+      if (this.listeners.has(target) || this.inflight.has(target)) return true;
+      for (const alias of _nullishCoalesce(this.aliasesByTarget.get(target), () => ( []))) related.add(alias);
+    }
+    return false;
+  }
+  alias(alias, key) {
+    const resolved = this.resolveKey(key);
+    if (alias === resolved) return;
+    const aliasEntry = this.entries.get(alias);
+    const aliasInvalidatedAt = _nullishCoalesce(this.invalidatedAt.get(alias), () => ( _optionalChain([aliasEntry, 'optionalAccess', _19 => _19.invalidatedAt])));
+    const resolvedInvalidatedAt = this.invalidatedAt.get(resolved);
+    if (aliasEntry && !this.entries.has(resolved)) {
+      this.entries.set(resolved, aliasEntry);
+      _optionalChain([this, 'access', _20 => _20.persistence, 'optionalAccess', _21 => _21.onSet, 'call', _22 => _22(resolved, aliasEntry)]);
+    }
+    if (this.entries.delete(alias)) _optionalChain([this, 'access', _23 => _23.persistence, 'optionalAccess', _24 => _24.onDelete, 'call', _25 => _25(alias)]);
+    this.invalidatedAt.delete(alias);
+    const invalidatedAt = [aliasInvalidatedAt, resolvedInvalidatedAt].reduce(
+      (latest, value) => value === void 0 ? latest : latest === void 0 ? value : Math.max(latest, value),
+      void 0
+    );
+    const resolvedEntry = this.entries.get(resolved);
+    if (invalidatedAt !== void 0 && (!resolvedEntry || invalidatedAt > resolvedEntry.updatedAt)) {
+      this.invalidatedAt.set(resolved, invalidatedAt);
+      if (resolvedEntry) {
+        this.entries.set(resolved, {
+          ...resolvedEntry,
+          staleAt: 0,
+          invalidatedAt
+        });
+      }
+    } else if (invalidatedAt !== void 0) {
+      this.invalidatedAt.delete(resolved);
+      if (_optionalChain([resolvedEntry, 'optionalAccess', _26 => _26.invalidatedAt]) !== void 0) {
+        this.entries.set(resolved, { ...resolvedEntry, invalidatedAt: void 0 });
+      }
+    }
+    const aliasInflight = this.inflight.get(alias);
+    if (aliasInflight && !this.inflight.has(resolved)) {
+      this.inflight.set(resolved, aliasInflight);
+    }
+    this.inflight.delete(alias);
+    if (this.pendingMetadataSweeps.delete(alias) && !this.entries.has(resolved)) {
+      this.pendingMetadataSweeps.add(resolved);
+    }
+    const previousTarget = this.aliases.get(alias);
+    if (previousTarget !== resolved) {
+      const previousResolved = previousTarget !== void 0 && this.pendingMetadataSweeps.size > 0 ? this.resolveKey(alias) : void 0;
+      this.removeAlias(alias);
+      this.aliases.set(alias, resolved);
+      let aliases = this.aliasesByTarget.get(resolved);
+      if (!aliases) this.aliasesByTarget.set(resolved, aliases = /* @__PURE__ */ new Set());
+      aliases.add(alias);
+      if (previousResolved !== void 0) this.sweepPendingEntryMetadata(previousResolved);
+    }
+    this.emit(alias);
+    this.emit(resolved, this.invalidatedAt.has(resolved) ? "invalidate" : void 0);
+  }
+  subscribe(key, listener) {
+    let listeners = this.listeners.get(key);
+    if (!listeners) {
+      listeners = /* @__PURE__ */ new Set();
+      this.listeners.set(key, listeners);
+    }
+    listeners.add(listener);
+    return () => {
+      listeners.delete(listener);
+      if (listeners.size === 0 && this.listeners.get(key) === listeners) {
+        this.listeners.delete(key);
+        this.sweepPendingEntryMetadata(key);
+      }
+    };
+  }
+  getInflight(key) {
+    return this.inflight.get(this.resolveKey(key));
+  }
+  setInflight(key, promise) {
+    this.inflight.set(this.resolveKey(key), promise);
+  }
+  deleteInflight(key) {
+    const resolved = this.resolveKey(key);
+    if (this.inflight.delete(resolved)) this.sweepPendingEntryMetadata(resolved);
+  }
+  scheduleGcSweep() {
+    if (this.gcSweepIntervalMs === false || this.gcTimer !== void 0) return;
+    const timer = setTimeout(() => {
+      this.gcTimer = void 0;
+      this.sweepExpiredEntries();
+    }, this.gcSweepIntervalMs);
+    _optionalChain([timer, 'access', _27 => _27.unref, 'optionalCall', _28 => _28()]);
+    this.gcTimer = timer;
+  }
+  sweepExpiredEntries(now = Date.now()) {
+    const watched = /* @__PURE__ */ new Set();
+    for (const key of this.listeners.keys()) watched.add(this.resolveKey(key));
+    let remaining = false;
+    const swept = /* @__PURE__ */ new Set();
+    for (const [key, entry] of this.entries) {
+      if (entry.gcAt === void 0) continue;
+      if (now < entry.gcAt || entry.fetching || this.inflight.has(key) || watched.has(key)) {
+        remaining = true;
+        continue;
+      }
+      this.entries.delete(key);
+      _optionalChain([this, 'access', _29 => _29.persistence, 'optionalAccess', _30 => _30.onDelete, 'call', _31 => _31(key)]);
+      swept.add(key);
+    }
+    if (swept.size > 0) this.sweepEntryMetadata(swept);
+    if (remaining) this.scheduleGcSweep();
+  }
+  /**
+   * Entry eviction alone leaves the per-key metadata behind. `invalidatedAt`
+   * marks and provisional aliases are created per query invocation, so with
+   * dynamic keys they accumulate for the lifetime of the page even though the
+   * entries they describe are long gone.
+   */
+  sweepEntryMetadata(swept) {
+    const protectedKeys = /* @__PURE__ */ new Set();
+    for (const key of swept) if (this.hasMetadataOwner(key)) protectedKeys.add(key);
+    for (const key of swept) {
+      if (this.entries.has(key)) {
+        this.pendingMetadataSweeps.delete(key);
+      } else if (protectedKeys.has(key)) {
+        this.pendingMetadataSweeps.add(key);
+      } else {
+        this.pendingMetadataSweeps.delete(key);
+        this.invalidatedAt.delete(key);
+      }
+    }
+    const related = /* @__PURE__ */ new Set();
+    const targets = new Set(swept);
+    for (const target of targets) {
+      for (const alias of _nullishCoalesce(this.aliasesByTarget.get(target), () => ( []))) {
+        related.add(alias);
+        targets.add(alias);
+      }
+    }
+    const removable = [];
+    for (const alias of related) {
+      if (this.entries.has(alias) || this.listeners.has(alias) || this.inflight.has(alias))
+        continue;
+      const resolved = this.resolveKey(alias);
+      if (!swept.has(resolved)) continue;
+      if (this.entries.has(resolved) || protectedKeys.has(resolved)) continue;
+      removable.push(alias);
+    }
+    for (const alias of removable) {
+      this.removeAlias(alias);
+      this.invalidatedAt.delete(alias);
+    }
+  }
+  removeAlias(alias) {
+    const target = this.aliases.get(alias);
+    if (target === void 0) return;
+    this.aliases.delete(alias);
+    const aliases = this.aliasesByTarget.get(target);
+    _optionalChain([aliases, 'optionalAccess', _32 => _32.delete, 'call', _33 => _33(alias)]);
+    if (_optionalChain([aliases, 'optionalAccess', _34 => _34.size]) === 0) this.aliasesByTarget.delete(target);
+  }
+  sweepPendingEntryMetadata(key) {
+    if (this.pendingMetadataSweeps.size === 0) return;
+    if (key !== void 0) {
+      const resolved = this.resolveKey(key);
+      if (this.pendingMetadataSweeps.has(resolved)) {
+        this.sweepEntryMetadata(/* @__PURE__ */ new Set([resolved]));
+      }
+      return;
+    }
+    this.sweepEntryMetadata(new Set(this.pendingMetadataSweeps));
+  }
+  emit(key, event) {
+    this.notifyListeners(key, event);
+    if (this.listeners.size === 0) return;
+    for (const [alias, target] of this.aliases) {
+      if (!this.listeners.has(alias)) continue;
+      if (this.resolveKey(target) === key) {
+        this.notifyListeners(alias, event);
+      }
+    }
+  }
+  notifyListeners(key, event) {
+    for (const listener of _nullishCoalesce(this.listeners.get(key), () => ( []))) {
+      try {
+        listener(event);
+      } catch (error) {
+        const detail = error instanceof Error ? _nullishCoalesce(error.stack, () => ( error.message)) : String(error);
+        console.warn(`[farm:client-cache] cache listener failed: ${detail}`);
+      }
+    }
+  }
+};
+_chunkS3JO3N4Hcjs.__name.call(void 0, _FarmClientDataCache, "FarmClientDataCache");
+var FarmClientDataCache = _FarmClientDataCache;
+var FARM_CLIENT_DATA_CACHE = /* @__PURE__ */ Symbol.for("farm.clientDataCache");
+var clientCacheGlobal = globalThis;
+var sharedFarmClientDataCache = _nullishCoalesce(clientCacheGlobal[FARM_CLIENT_DATA_CACHE], () => ( (clientCacheGlobal[FARM_CLIENT_DATA_CACHE] = new FarmClientDataCache())));
+function getFarmClientDataCache() {
+  return sharedFarmClientDataCache;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getFarmClientDataCache, "getFarmClientDataCache");
+function normalizeFarmClientCacheKey(key) {
+  return typeof key === "string" ? key : _chunkH6G5INWMcjs.createRouteDataCacheKey.call(void 0, key);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeFarmClientCacheKey, "normalizeFarmClientCacheKey");
+
+
+
+
+
+
+exports.trackFarmClientCacheInvalidations = trackFarmClientCacheInvalidations; exports.FarmClientDataCache = FarmClientDataCache; exports.getFarmClientDataCache = getFarmClientDataCache; exports.normalizeFarmClientCacheKey = normalizeFarmClientCacheKey;

package/dist/chunk-IAMRBF3Z.cjs

@@ -0,0 +1,86 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } }
+
+
+var _chunk6V4TDWECcjs = require('./chunk-6V4TDWEC.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/routes.server.ts
+var _fs = require('fs');
+var _path = require('path');
+async function loadProgrammaticRouteManifests(options) {
+  const manifests = [];
+  const routeFiles = findProgrammaticRouteFiles(options.root, options.srcDir);
+  if (routeFiles.length === 0) return manifests;
+  const { getProgrammaticRouteManifest } = await import("./routes.cjs");
+  for (const filePath of routeFiles) {
+    const mod = await options.loadModule(filePath);
+    const manifest = getProgrammaticRouteManifest(mod);
+    if (manifest) {
+      manifests.push({ filePath, manifest });
+    }
+  }
+  return manifests;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, loadProgrammaticRouteManifests, "loadProgrammaticRouteManifests");
+function findProgrammaticRouteFiles(root, srcDir = "src") {
+  return findProgrammaticRouteFilesInDir(_path.join.call(void 0, root, srcDir));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, findProgrammaticRouteFiles, "findProgrammaticRouteFiles");
+function findProgrammaticRouteFilesInDir(srcRoot) {
+  const files = [];
+  for (const fileName of _chunk6V4TDWECcjs.PROGRAMMATIC_ROUTE_FILE_NAMES) {
+    const filePath = _path.join.call(void 0, srcRoot, fileName);
+    if (_fs.existsSync.call(void 0, filePath)) {
+      files.push(filePath);
+    }
+  }
+  return files;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, findProgrammaticRouteFilesInDir, "findProgrammaticRouteFilesInDir");
+async function discoverProgrammaticRoutePaths(root, srcDir = "src") {
+  const paths = /* @__PURE__ */ new Set();
+  const files = /* @__PURE__ */ new Set([
+    ...findProgrammaticRouteFiles(root, srcDir),
+    ...await findProgrammaticRouteSourceFiles(_path.join.call(void 0, root, srcDir))
+  ]);
+  for (const filePath of files) {
+    const source = _fs.readFileSync.call(void 0, filePath, "utf8");
+    for (const routePath of _chunk6V4TDWECcjs.scanProgrammaticPagePaths.call(void 0, source)) {
+      paths.add(routePath);
+    }
+  }
+  return Array.from(paths).sort();
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, discoverProgrammaticRoutePaths, "discoverProgrammaticRoutePaths");
+async function findProgrammaticRouteSourceFiles(srcRoot) {
+  if (!_fs.existsSync.call(void 0, srcRoot)) {
+    return [];
+  }
+  try {
+    const glob = await import("fast-glob");
+    return await glob.default("**/*.{ts,tsx,js,jsx}", {
+      cwd: srcRoot,
+      absolute: true,
+      ignore: [
+        "**/*.d.ts",
+        "**/node_modules/**",
+        "**/.*/**",
+        "farm-routes.d.ts",
+        "farm-env.d.ts",
+        "lib/api.generated.ts"
+      ]
+    });
+  } catch (e) {
+    return [];
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, findProgrammaticRouteSourceFiles, "findProgrammaticRouteSourceFiles");
+
+
+
+
+
+
+exports.loadProgrammaticRouteManifests = loadProgrammaticRouteManifests; exports.findProgrammaticRouteFiles = findProgrammaticRouteFiles; exports.findProgrammaticRouteFilesInDir = findProgrammaticRouteFilesInDir; exports.discoverProgrammaticRoutePaths = discoverProgrammaticRoutePaths;

package/dist/chunk-IQXFRNY2.cjs

@@ -0,0 +1,169 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkHBTUGXHScjs = require('./chunk-HBTUGXHS.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.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 = _chunkHBTUGXHScjs.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 };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, readFarmI18nCatalogs, "readFarmI18nCatalogs");
+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 = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (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");
+  visit(input, []);
+  return output;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, flattenFarmI18nCatalog, "flattenFarmI18nCatalog");
+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;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, analyzeFarmI18nMessage, "analyzeFarmI18nMessage");
+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}".`
+      );
+    }
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, validateFarmI18nCatalogs, "validateFarmI18nCatalogs");
+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);
+      }
+    }
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, collectArguments, "collectArguments");
+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;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, addArgument, "addArgument");
+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);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, sameSignature, "sameSignature");
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isPlainObject, "isPlainObject");
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, messageOf, "messageOf");
+
+
+
+exports.readFarmI18nCatalogs = readFarmI18nCatalogs;