@farm.js/core 0.1.46 → 0.1.48

package/dist/chunk-63H6BKXG.cjs

@@ -1,389 +0,0 @@
-"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 _chunkNYJMY3JAcjs = require('./chunk-NYJMY3JA.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 : _chunkNYJMY3JAcjs.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-64SBBZDU.cjs

@@ -1,102 +0,0 @@
-"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 _chunkSVRTJOUFcjs = require('./chunk-SVRTJOUF.cjs');
-
-
-var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
-
-// src/integration-request-security.ts
-function resolveIntegrationAllowedOrigins(values, label) {
-  return Object.freeze((_nullishCoalesce(values, () => ( []))).map((value) => _chunkSVRTJOUFcjs.normalizeAllowedOriginPattern.call(void 0, value, label)));
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, resolveIntegrationAllowedOrigins, "resolveIntegrationAllowedOrigins");
-function validateIntegrationRequestOrigin(request, policy = {}) {
-  const allowedOrigins = _nullishCoalesce(policy.allowedOrigins, () => ( []));
-  const requireOriginMetadata = _nullishCoalesce(policy.requireOriginMetadata, () => ( true));
-  const fetchSite = _optionalChain([request, 'access', _ => _.headers, 'access', _2 => _2.get, 'call', _3 => _3("sec-fetch-site"), 'optionalAccess', _4 => _4.trim, 'call', _5 => _5(), 'access', _6 => _6.toLowerCase, 'call', _7 => _7()]);
-  const source = _chunkSVRTJOUFcjs.getRequestSourceOrigin.call(void 0, request);
-  if (!source.ok) {
-    return { ok: false, reason: source.reason };
-  }
-  if (source.origin === null) {
-    if (fetchSite === "same-origin") {
-      return { ok: true };
-    }
-    if (requireOriginMetadata) {
-      return { ok: false, reason: fetchSite === "cross-site" ? "cross-site" : "missing-origin" };
-    }
-    return fetchSite === "cross-site" ? { ok: false, reason: "cross-site" } : { ok: true };
-  }
-  const requestUrl = new URL(request.url);
-  const matchesConfiguredOrigin = allowedOrigins.some(
-    (pattern) => _chunkSVRTJOUFcjs.matchesAllowedOrigin.call(void 0, source.origin, pattern)
-  );
-  const matchesRequest = source.origin === requestUrl.origin || _chunkSVRTJOUFcjs.matchesHostHeader.call(void 0, source.origin, request);
-  if (!matchesRequest && !matchesConfiguredOrigin) {
-    return { ok: false, reason: "cross-site" };
-  }
-  if (fetchSite === "cross-site" && !matchesConfiguredOrigin) {
-    return { ok: false, reason: "cross-site" };
-  }
-  return { ok: true };
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, validateIntegrationRequestOrigin, "validateIntegrationRequestOrigin");
-function describeIntegrationOriginRejection(reason) {
-  switch (reason) {
-    case "missing-origin":
-      return "Request is missing same-origin metadata.";
-    case "opaque-origin":
-      return "Opaque origins are not allowed.";
-    case "invalid-origin":
-      return "Invalid request origin.";
-    case "cross-site":
-      return "Cross-site request was rejected.";
-  }
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, describeIntegrationOriginRejection, "describeIntegrationOriginRejection");
-
-// src/api/route-schema.ts
-async function parseRouteSchema(schema, value) {
-  if (schema.parseAsync) return schema.parseAsync(value);
-  if (schema["~standard"]) {
-    const result = await schema["~standard"].validate(value);
-    if (result.issues)
-      throw Object.assign(new Error("Validation failed"), { issues: result.issues });
-    return result.value;
-  }
-  if (schema.parse) return schema.parse(value);
-  throw new TypeError("Route validators must implement Standard Schema or parse().");
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, parseRouteSchema, "parseRouteSchema");
-var PUBLIC_MESSAGE_CODES = /* @__PURE__ */ new Set(["custom", "invalid_type"]);
-function toPublicValidationIssues(error) {
-  const issues = _optionalChain([error, 'optionalAccess', _8 => _8.issues]);
-  const list = Array.isArray(issues) ? issues : Array.isArray(_optionalChain([error, 'optionalAccess', _9 => _9.errors])) ? error.errors : [];
-  return list.map((issue) => {
-    const { path, code, message } = _nullishCoalesce(issue, () => ( {}));
-    return {
-      path: Array.isArray(path) ? path.map(toPublicPathSegment) : [],
-      ...typeof code === "string" ? { code } : {},
-      message: PUBLIC_MESSAGE_CODES.has(code) && typeof message === "string" && message ? message : "Invalid value"
-    };
-  });
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, toPublicValidationIssues, "toPublicValidationIssues");
-function toPublicPathSegment(segment) {
-  const key = segment && typeof segment === "object" && "key" in segment ? segment.key : segment;
-  if (typeof key === "number") return key;
-  if (typeof key === "symbol") return key.description || key.toString();
-  return String(key);
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, toPublicPathSegment, "toPublicPathSegment");
-
-
-
-
-
-
-
-exports.resolveIntegrationAllowedOrigins = resolveIntegrationAllowedOrigins; exports.validateIntegrationRequestOrigin = validateIntegrationRequestOrigin; exports.describeIntegrationOriginRejection = describeIntegrationOriginRejection; exports.parseRouteSchema = parseRouteSchema; exports.toPublicValidationIssues = toPublicValidationIssues;

package/dist/chunk-666CKENS.mjs

@@ -1,49 +0,0 @@
-import {
-  compiledFarmI18nMessages,
-  getFarmI18nClientState
-} from "./chunk-IHQIOZLC.mjs";
-import {
-  __name
-} from "./chunk-LPEX4YW6.mjs";
-
-// src/i18n/client-runtime.ts
-import IntlMessageFormat from "intl-messageformat";
-var readOwnMessage = /* @__PURE__ */ __name((messages, key) => Object.prototype.hasOwnProperty.call(messages, key) ? messages[key] : void 0, "readOwnMessage");
-var translate = /* @__PURE__ */ __name((key, values, rich = false) => {
-  const snapshot = requireSnapshot();
-  const message = readOwnMessage(snapshot.messages, key);
-  if (message === void 0) return key;
-  const cacheKey = `${snapshot.locale}\0${key}\0${message}`;
-  let formatter = compiledFarmI18nMessages.get(cacheKey);
-  if (!formatter) {
-    formatter = new IntlMessageFormat(message, snapshot.locale);
-    compiledFarmI18nMessages.set(cacheKey, formatter);
-  }
-  const result = formatter.format(values);
-  if (rich) return Array.isArray(result) && result.length === 1 ? result[0] : result;
-  if (Array.isArray(result) && result.some((part) => typeof part !== "string")) {
-    throw new Error(`Farm i18n message "${key}" contains rich content. Render it with t.rich().`);
-  }
-  return Array.isArray(result) ? result.join("") : String(result);
-}, "translate");
-var t = /* @__PURE__ */ __name(((key, values) => translate(key, values)), "t");
-t.rich = (key, values) => translate(key, values, true);
-t.raw = (key) => readOwnMessage(requireSnapshot().messages, key) ?? key;
-t.has = (key) => Object.prototype.hasOwnProperty.call(requireSnapshot().messages, key);
-function createFarmClientTranslator() {
-  return ((key, ...args) => t(key, ...args));
-}
-__name(createFarmClientTranslator, "createFarmClientTranslator");
-function requireSnapshot() {
-  const snapshot = getFarmI18nClientState();
-  if (!snapshot) {
-    throw new Error("Farm i18n is not configured or has not been hydrated.");
-  }
-  return snapshot;
-}
-__name(requireSnapshot, "requireSnapshot");
-
-export {
-  t,
-  createFarmClientTranslator
-};

package/dist/chunk-6BWKJ6QS.cjs

@@ -1,43 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-
-var _chunkM7MKQXAFcjs = require('./chunk-M7MKQXAF.cjs');
-
-
-var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
-
-// src/middleware/path.ts
-function appendMiddlewareRoutePath(routePath, directoryName) {
-  const marker = _chunkM7MKQXAFcjs.parseInterceptionMarker.call(void 0, directoryName);
-  if (marker) {
-    const owner = routePath.split("/").filter(Boolean);
-    const parts = [
-      ...marker.root ? [] : owner.slice(0, Math.max(0, owner.length - marker.up)),
-      ...marker.remainder ? [marker.remainder] : []
-    ];
-    return `/${parts.join("/")}`;
-  }
-  if (directoryName.startsWith("(") && directoryName.endsWith(")") || _chunkM7MKQXAFcjs.isRouteSlotSegment.call(void 0, directoryName)) {
-    return routePath;
-  }
-  return routePath === "/" ? `/${directoryName}` : `${routePath}/${directoryName}`;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, appendMiddlewareRoutePath, "appendMiddlewareRoutePath");
-function appendMiddlewareDirectory(directory, directoryName) {
-  return directory === "" ? directoryName : `${directory}/${directoryName}`;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, appendMiddlewareDirectory, "appendMiddlewareDirectory");
-function countSegments(value) {
-  return value.split("/").filter(Boolean).length;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, countSegments, "countSegments");
-function compareMiddlewareRouteLocations(left, right) {
-  return countSegments(left.path) - countSegments(right.path) || left.path.localeCompare(right.path) || countSegments(left.directory) - countSegments(right.directory) || left.directory.localeCompare(right.directory);
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, compareMiddlewareRouteLocations, "compareMiddlewareRouteLocations");
-
-
-
-
-
-exports.appendMiddlewareRoutePath = appendMiddlewareRoutePath; exports.appendMiddlewareDirectory = appendMiddlewareDirectory; exports.compareMiddlewareRouteLocations = compareMiddlewareRouteLocations;