@farm.js/core 0.1.61 → 0.1.63

package/dist/chunk-W6QLRQ3V.mjs

@@ -0,0 +1,152 @@
+// src/api/config.ts
+var DEFAULT_FARM_API_BASE_PATH = "/api";
+async function resolveFarmAPIConfig(config, context) {
+  const configuredBasePath = await resolveConfigValue(config?.basePath, context, "api.basePath");
+  const basePath = normalizeFarmAPIBasePath(configuredBasePath ?? DEFAULT_FARM_API_BASE_PATH);
+  const configuredBaseURL = await resolveConfigValue(config?.baseURL, context, "api.baseURL");
+  return normalizeFarmAPIConfig({ baseURL: configuredBaseURL, basePath });
+}
+function normalizeFarmAPIConfig(config) {
+  const basePath = normalizeFarmAPIBasePath(config?.basePath ?? DEFAULT_FARM_API_BASE_PATH);
+  const baseURL = config?.baseURL?.trim();
+  if (!baseURL) {
+    return { baseURL: basePath, basePath };
+  }
+  if (baseURL.startsWith("//")) {
+    throw new Error(
+      'Farm api.baseURL must be an absolute URL or a root-relative path such as "/api", not a network-path reference.'
+    );
+  }
+  if (baseURL.startsWith("/")) {
+    const url2 = parseRootRelativeBaseURL(baseURL);
+    if (url2.pathname !== "/") {
+      const effectivePath = normalizeFarmAPIBasePath(url2.pathname);
+      return { baseURL: effectivePath, basePath: effectivePath };
+    }
+    return { baseURL: basePath, basePath };
+  }
+  let url;
+  try {
+    url = new URL(baseURL);
+  } catch {
+    throw new Error(
+      'Farm api.baseURL must be an absolute URL or a root-relative path such as "/api".'
+    );
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error("Farm api.baseURL must use http or https.");
+  }
+  if (url.search || url.hash) {
+    throw new Error("Farm api.baseURL cannot contain a query string or hash.");
+  }
+  if (url.pathname !== "/") {
+    const effectivePath = normalizeFarmAPIBasePath(url.pathname);
+    return {
+      baseURL: `${url.origin}${effectivePath}`,
+      basePath: effectivePath
+    };
+  }
+  return {
+    baseURL: basePath === "/" ? url.origin : `${url.origin}${basePath}`,
+    basePath
+  };
+}
+function normalizeFarmAPIBasePath(value) {
+  const hasUnstableCharacters = (candidate) => candidate.includes("\\") || Array.from(candidate).some((character) => {
+    const code = character.charCodeAt(0);
+    return code <= 31 || code >= 127 && code <= 159;
+  });
+  if (hasUnstableCharacters(value)) {
+    throw new Error("Farm api.basePath cannot contain backslashes or control characters.");
+  }
+  const path = value.trim();
+  if (!path) {
+    throw new Error("Farm api.basePath cannot be empty.");
+  }
+  if (path.includes("?") || path.includes("#")) {
+    throw new Error("Farm api.basePath cannot contain a query string or hash.");
+  }
+  if (path.startsWith("//")) {
+    throw new Error('Farm api.basePath must be a pathname such as "/api", not a URL.');
+  }
+  for (const segment of path.split("/")) {
+    let decoded = segment;
+    try {
+      decoded = decodeURIComponent(segment);
+    } catch {
+    }
+    if (hasUnstableCharacters(decoded)) {
+      throw new Error("Farm api.basePath cannot contain backslashes or control characters.");
+    }
+    if (decoded.includes("/")) {
+      throw new Error("Farm api.basePath cannot contain percent-encoded path separators.");
+    }
+    if (decoded === "." || decoded === "..") {
+      throw new Error('Farm api.basePath cannot contain "." or ".." path segments.');
+    }
+  }
+  const normalized = `/${path.replace(/^\/+|\/+$/g, "")}`;
+  return normalized === "/" ? "/" : normalized;
+}
+function getFarmAPIBaseURL() {
+  if (typeof __FARM_API_BASE_URL__ !== "undefined" && __FARM_API_BASE_URL__) {
+    return __FARM_API_BASE_URL__;
+  }
+  return DEFAULT_FARM_API_BASE_PATH;
+}
+function resolveFarmAPIRequestURL(routePath, baseURL = getFarmAPIBaseURL(), fallbackOrigin = getDefaultOrigin()) {
+  const base = new URL(baseURL, fallbackOrigin);
+  if (base.pathname === "/") {
+    return new URL(routePath, base);
+  }
+  const route = new URL(routePath, fallbackOrigin);
+  const suffix = stripCanonicalAPIBasePath(route.pathname);
+  const joinedPath = joinURLPath(base.pathname, suffix);
+  base.pathname = joinedPath;
+  base.search = route.search;
+  base.hash = route.hash;
+  return base;
+}
+async function resolveConfigValue(value, context, name) {
+  const resolved = typeof value === "function" ? await value(context) : value;
+  if (resolved === void 0) return void 0;
+  if (typeof resolved !== "string") {
+    throw new Error(`Farm ${name} must resolve to a string or undefined.`);
+  }
+  if (!resolved.trim()) {
+    throw new Error(`Farm ${name} cannot be empty.`);
+  }
+  return resolved;
+}
+function parseRootRelativeBaseURL(value) {
+  const url = new URL(value, "http://farm.local");
+  if (url.search || url.hash) {
+    throw new Error("Farm api.baseURL cannot contain a query string or hash.");
+  }
+  return url;
+}
+function stripCanonicalAPIBasePath(pathname) {
+  if (pathname === DEFAULT_FARM_API_BASE_PATH) return "";
+  if (pathname.startsWith(`${DEFAULT_FARM_API_BASE_PATH}/`)) {
+    return pathname.slice(DEFAULT_FARM_API_BASE_PATH.length + 1);
+  }
+  return pathname.replace(/^\/+/, "");
+}
+function joinURLPath(basePath, suffix) {
+  const normalizedBase = basePath === "/" ? "" : basePath.replace(/\/+$/, "");
+  const normalizedSuffix = suffix.replace(/^\/+/, "");
+  if (!normalizedSuffix) return normalizedBase || "/";
+  return `${normalizedBase}/${normalizedSuffix}`;
+}
+function getDefaultOrigin() {
+  return typeof window !== "undefined" && window.location ? window.location.origin : "http://localhost:3000";
+}
+
+export {
+  DEFAULT_FARM_API_BASE_PATH,
+  resolveFarmAPIConfig,
+  normalizeFarmAPIConfig,
+  normalizeFarmAPIBasePath,
+  getFarmAPIBaseURL,
+  resolveFarmAPIRequestURL
+};

package/dist/chunk-WCLLPR6H.mjs

@@ -0,0 +1,35 @@
+// src/agent-json-ld.ts
+function pruneUndefined(object) {
+  const result = {};
+  for (const [key, value] of Object.entries(object)) {
+    if (value !== void 0 && value !== null && value !== "") result[key] = value;
+  }
+  return result;
+}
+function serializeJsonLd(value) {
+  return JSON.stringify(value).replace(/</g, "\\u003c");
+}
+function renderFarmAgentJsonLd(config, context) {
+  const base = pruneUndefined({
+    name: config.name ?? context.siteName ?? context.title,
+    url: config.url ?? context.metadataBase,
+    description: config.description ?? context.description,
+    logo: config.logo,
+    sameAs: config.sameAs && config.sameAs.length > 0 ? config.sameAs : void 0
+  });
+  const object = {
+    "@context": "https://schema.org",
+    "@type": config.type || "Organization",
+    ...base,
+    ...config.properties || {}
+  };
+  if (Object.keys(object).length <= 2 && !config.properties) {
+    return "";
+  }
+  return `<script type="application/ld+json">${serializeJsonLd(object)}</script>`;
+}
+
+export {
+  serializeJsonLd,
+  renderFarmAgentJsonLd
+};

package/dist/chunk-WEGAVN37.cjs

@@ -0,0 +1,45 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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; }// src/theme/runtime.ts
+var FALLBACK_CLIENT_SNAPSHOT = Object.freeze({
+  theme: "system",
+  resolvedTheme: "light",
+  mounted: true
+});
+var cachedClientSnapshot = FALLBACK_CLIENT_SNAPSHOT;
+function snapshotsMatch(left, right) {
+  return left.theme === right.theme && left.resolvedTheme === right.resolvedTheme && left.mounted === right.mounted;
+}
+function getTheme() {
+  const next = typeof window === "undefined" ? FALLBACK_CLIENT_SNAPSHOT : _optionalChain([window, 'access', _ => _.__FARM_THEME__, 'optionalAccess', _2 => _2.snapshot]);
+  if (!next) return cachedClientSnapshot;
+  if (!snapshotsMatch(cachedClientSnapshot, next)) cachedClientSnapshot = next;
+  return cachedClientSnapshot;
+}
+function setTheme(theme) {
+  const runtime = typeof window === "undefined" ? void 0 : window.__FARM_THEME__;
+  if (!runtime) {
+    throw new Error("The FARMJS theme runtime is not enabled. Add `theme` to farm.config.ts.");
+  }
+  runtime.setTheme(theme);
+}
+function toggleTheme() {
+  const next = getTheme().resolvedTheme === "dark" ? "light" : "dark";
+  setTheme(next);
+  return next;
+}
+function subscribeTheme(listener) {
+  if (typeof window === "undefined") return () => {
+  };
+  const handleThemeChange = () => {
+    getTheme();
+    listener();
+  };
+  window.addEventListener("farm:themechange", handleThemeChange);
+  return () => window.removeEventListener("farm:themechange", handleThemeChange);
+}
+
+
+
+
+
+
+exports.getTheme = getTheme; exports.setTheme = setTheme; exports.toggleTheme = toggleTheme; exports.subscribeTheme = subscribeTheme;

package/dist/chunk-WFVSAT7Y.cjs

@@ -0,0 +1,83 @@
+"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 _chunkN4AQNEXRcjs = require('./chunk-N4AQNEXR.cjs');
+
+
+
+var _chunkEX6ZSN5Pcjs = require('./chunk-EX6ZSN5P.cjs');
+
+
+var _chunkI2BYNELAcjs = require('./chunk-I2BYNELA.cjs');
+
+// src/server-query-client.ts
+var _react = require('react');
+function useServerQuery(query, input, options = {}) {
+  const cache = _chunkI2BYNELAcjs.getFarmClientDataCache.call(void 0, );
+  const key = _chunkEX6ZSN5Pcjs.createServerQueryCallKey.call(void 0, query, input);
+  const inputRef = _react.useRef.call(void 0, input);
+  const optionsRef = _react.useRef.call(void 0, options);
+  const mountedKeyRef = _react.useRef.call(void 0, void 0);
+  const pendingInvalidationRef = _react.useRef.call(void 0, false);
+  inputRef.current = input;
+  optionsRef.current = options;
+  const subscribe = _react.useCallback.call(void 0, 
+    (listener) => cache.subscribe(key, (event) => {
+      if (event === "invalidate") pendingInvalidationRef.current = true;
+      else if (_optionalChain([cache, 'access', _ => _.get, 'call', _2 => _2(key), 'optionalAccess', _3 => _3.fetching])) {
+        pendingInvalidationRef.current = false;
+      }
+      listener();
+    }),
+    [cache, key]
+  );
+  const getSnapshot = _react.useCallback.call(void 0, () => cache.get(key), [cache, key]);
+  const entry = _react.useSyncExternalStore.call(void 0, subscribe, getSnapshot, () => void 0);
+  const run = _react.useCallback.call(void 0, 
+    (force = false) => {
+      pendingInvalidationRef.current = false;
+      return _chunkEX6ZSN5Pcjs.fetchServerQuery.call(void 0, query, inputRef.current, {
+        ...optionsRef.current,
+        force
+      });
+    },
+    [query]
+  );
+  _react.useEffect.call(void 0, () => {
+    if (options.enabled === false) {
+      mountedKeyRef.current = void 0;
+      return;
+    }
+    const firstReadForKey = mountedKeyRef.current !== key;
+    if (firstReadForKey) mountedKeyRef.current = key;
+    if (firstReadForKey && (!entry || cache.isStale(key)) || pendingInvalidationRef.current && _optionalChain([entry, 'optionalAccess', _4 => _4.invalidatedAt]) !== void 0 && !entry.fetching) {
+      void run().catch(() => void 0);
+    }
+  }, [cache, entry, key, options.enabled, run]);
+  _react.useEffect.call(void 0, () => {
+    if (options.enabled === false) return;
+    return _chunkN4AQNEXRcjs.attachRevalidationListeners.call(void 0, 
+      () => {
+        if (cache.isStale(key)) void run().catch(() => void 0);
+      },
+      {
+        refetchOnWindowFocus: options.refetchOnWindowFocus,
+        refetchOnReconnect: options.refetchOnReconnect
+      }
+    );
+  }, [cache, key, options.enabled, options.refetchOnReconnect, options.refetchOnWindowFocus, run]);
+  const status = _nullishCoalesce(_optionalChain([entry, 'optionalAccess', _5 => _5.status]), () => ( (entry ? "success" : "idle")));
+  const fetching = _nullishCoalesce(_optionalChain([entry, 'optionalAccess', _6 => _6.fetching]), () => ( false));
+  return {
+    data: _optionalChain([entry, 'optionalAccess', _7 => _7.data]),
+    error: _nullishCoalesce(_optionalChain([entry, 'optionalAccess', _8 => _8.error]), () => ( null)),
+    status,
+    pending: status === "pending" && (_nullishCoalesce(_optionalChain([entry, 'optionalAccess', _9 => _9.updatedAt]), () => ( 0))) === 0,
+    fetching,
+    stale: cache.isStale(key),
+    refetch: () => run(true)
+  };
+}
+
+
+
+exports.useServerQuery = useServerQuery;

package/dist/chunk-WKPBIT5Q.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 _chunkYN6BHOYYcjs = require('./chunk-YN6BHOYY.cjs');
+
+
+var _chunkMPU5DOXXcjs = require('./chunk-MPU5DOXX.cjs');
+
+
+var _chunk4P5634G6cjs = require('./chunk-4P5634G6.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 = _chunkYN6BHOYYcjs.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 _chunkYN6BHOYYcjs._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 _chunk4P5634G6cjs.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
+    }
+  });
+  _chunkYN6BHOYYcjs._attachServerFunctionDescriptor.call(void 0, 
+    query,
+    _chunkYN6BHOYYcjs.createServerFunctionDescriptor.call(void 0, "query", options, async (value) => {
+      const result = await _chunkYN6BHOYYcjs._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-WNDAISB7.mjs

@@ -0,0 +1,51 @@
+// src/instrumentation-runtime.ts
+function createFarmInstrumentationLifecycle(module, context) {
+  let startPromise;
+  let shutdownPromise;
+  let cleanup;
+  return {
+    start() {
+      if (!startPromise) {
+        startPromise = Promise.resolve(module?.register?.(context)).then((result) => {
+          cleanup = result || void 0;
+        });
+      }
+      return startPromise;
+    },
+    shutdown() {
+      if (!shutdownPromise) {
+        shutdownPromise = (async () => {
+          try {
+            await startPromise;
+          } catch {
+          }
+          try {
+            if (typeof cleanup === "function") {
+              await cleanup();
+            } else if (cleanup?.shutdown) {
+              await cleanup.shutdown();
+            }
+          } finally {
+            if (module?.shutdown) {
+              await module.shutdown();
+            }
+          }
+        })();
+      }
+      return shutdownPromise;
+    }
+  };
+}
+function resolveFarmInstrumentationRuntime(preset) {
+  const normalized = preset?.toLowerCase() ?? "";
+  if (normalized.includes("cloudflare") || normalized.includes("worker") || normalized.includes("edge")) {
+    return "edge";
+  }
+  if (normalized.includes("bun")) return "bun";
+  return "nodejs";
+}
+
+export {
+  createFarmInstrumentationLifecycle,
+  resolveFarmInstrumentationRuntime
+};

package/dist/chunk-WNLPQW7W.mjs

@@ -0,0 +1,19 @@
+// src/schema-capabilities.ts
+function assertNoSchemaListField(field, fieldPath, target) {
+  if (!field.list) {
+    return;
+  }
+  throw new Error(
+    `Schema field "${fieldPath}" declares list: true, but ${target} does not support list fields. Use type: "json" for an array value or model the values in a related table.`
+  );
+}
+
+// src/schema-reference.ts
+function isDatabaseEnforcedReference(reference) {
+  return reference.enforced === void 0 || reference.enforced === "db";
+}
+
+export {
+  assertNoSchemaListField,
+  isDatabaseEnforcedReference
+};

package/dist/chunk-WT6RAN2I.cjs

@@ -0,0 +1,41 @@
+"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; }// src/theme/config.ts
+var DEFAULT_FARM_THEME_STORAGE_KEY = "farm-theme";
+var STORAGE_KEY_PATTERN = /^[A-Za-z0-9._-]+$/;
+function resolveFarmThemeConfig(config, basePath = "/") {
+  if (config && "enabled" in config) {
+    return config;
+  }
+  if (!config) {
+    return {
+      enabled: false,
+      default: "system",
+      storageKey: DEFAULT_FARM_THEME_STORAGE_KEY,
+      cookiePath: normalizeCookiePath(basePath)
+    };
+  }
+  const storageKey = _optionalChain([config, 'access', _ => _.storageKey, 'optionalAccess', _2 => _2.trim, 'call', _3 => _3()]) || DEFAULT_FARM_THEME_STORAGE_KEY;
+  if (!STORAGE_KEY_PATTERN.test(storageKey)) {
+    throw new Error(
+      "theme.storageKey may only contain letters, numbers, dots, underscores, and hyphens."
+    );
+  }
+  const defaultTheme = _nullishCoalesce(config.default, () => ( "system"));
+  if (defaultTheme !== "light" && defaultTheme !== "dark" && defaultTheme !== "system") {
+    throw new Error('theme.default must be "light", "dark", or "system".');
+  }
+  return {
+    enabled: true,
+    default: defaultTheme,
+    storageKey,
+    cookiePath: normalizeCookiePath(basePath)
+  };
+}
+function normalizeCookiePath(basePath) {
+  const normalized = `/${basePath}`.replace(/\/{2,}/g, "/");
+  if (normalized === "/") return normalized;
+  return normalized.replace(/\/$/, "");
+}
+
+
+
+exports.resolveFarmThemeConfig = resolveFarmThemeConfig;

package/dist/chunk-WXFY5JIY.mjs

@@ -0,0 +1,20 @@
+// src/utils/runtime-env.ts
+function getFarmRuntimeBindings() {
+  const runtimeBindings = globalThis.__env__;
+  return runtimeBindings && typeof runtimeBindings === "object" ? runtimeBindings : void 0;
+}
+function readFarmEnvironmentValue(name) {
+  const runtimeValue = getFarmRuntimeBindings()?.[name];
+  if (typeof runtimeValue === "string") return runtimeValue;
+  return typeof process !== "undefined" ? process.env?.[name] : void 0;
+}
+function isFarmDeployedRuntime() {
+  if (getFarmRuntimeBindings()) return true;
+  return readFarmEnvironmentValue("NODE_ENV") === "production";
+}
+
+export {
+  getFarmRuntimeBindings,
+  readFarmEnvironmentValue,
+  isFarmDeployedRuntime
+};