@farm.js/core 0.1.47 → 0.1.49

package/dist/chunk-P2355C6E.cjs

@@ -0,0 +1,186 @@
+"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/after.ts
+var _async_hooks = require('async_hooks');
+var AFTER_STORAGE = /* @__PURE__ */ Symbol.for("@farm.js/core/after-storage");
+function getAfterStorage() {
+  const runtime = globalThis;
+  const existing = runtime[AFTER_STORAGE];
+  if (existing instanceof _async_hooks.AsyncLocalStorage) {
+    return existing;
+  }
+  const storage = new (0, _async_hooks.AsyncLocalStorage)();
+  runtime[AFTER_STORAGE] = storage;
+  return storage;
+}
+var afterStorage = getAfterStorage();
+function defaultAfterErrorReporter(error) {
+  console.error("[Farm.js] after() callback failed:", error);
+}
+function reportAfterError(state, error) {
+  try {
+    state.reportError(error);
+  } catch (e) {
+  }
+}
+function createAfterRequestState(reportError = defaultAfterErrorReporter) {
+  let resolveResponseFinished;
+  let responseFinished = false;
+  const responseFinishedPromise = new Promise((resolve) => {
+    resolveResponseFinished = resolve;
+  });
+  const state = {
+    completion: Promise.resolve(),
+    finishResponse: () => {
+      if (responseFinished) return;
+      responseFinished = true;
+      resolveResponseFinished();
+    },
+    phase: "open",
+    reportError,
+    tasks: []
+  };
+  state.completion = responseFinishedPromise.then(
+    () => afterStorage.run(state, async () => {
+      state.phase = "running";
+      for (let index = 0; index < state.tasks.length; index++) {
+        const task = state.tasks[index];
+        task.start();
+        try {
+          await task.result;
+        } catch (error) {
+          reportAfterError(state, error);
+        }
+      }
+      state.phase = "closed";
+    })
+  );
+  return state;
+}
+function registerPlatformLifetime(state, context) {
+  if (!_optionalChain([context, 'optionalAccess', _ => _.waitUntil])) return;
+  try {
+    context.waitUntil(state.completion);
+  } catch (error) {
+    reportAfterError(state, error);
+  }
+}
+function registerResponseFinishedHook(state, context) {
+  if (!_optionalChain([context, 'optionalAccess', _2 => _2.onResponseFinished])) return false;
+  try {
+    context.onResponseFinished(state.finishResponse);
+    return true;
+  } catch (error) {
+    reportAfterError(state, error);
+    return false;
+  }
+}
+function finishSoon(state) {
+  setTimeout(state.finishResponse, 0);
+}
+function wrapResponseBody(response, request, state) {
+  if (request.method === "HEAD" || response.status < 200 || response.status > 599 || !response.body || response.bodyUsed || response.body.locked) {
+    finishSoon(state);
+    return response;
+  }
+  const reader = response.body.getReader();
+  let released = false;
+  const releaseReader = () => {
+    if (released) return;
+    released = true;
+    reader.releaseLock();
+  };
+  const body = new ReadableStream({
+    async pull(controller) {
+      try {
+        const chunk = await reader.read();
+        if (chunk.done) {
+          releaseReader();
+          controller.close();
+          finishSoon(state);
+          return;
+        }
+        controller.enqueue(chunk.value);
+      } catch (error) {
+        releaseReader();
+        controller.error(error);
+        finishSoon(state);
+      }
+    },
+    cancel(reason) {
+      try {
+        return reader.cancel(reason);
+      } finally {
+        releaseReader();
+        finishSoon(state);
+      }
+    }
+  });
+  return new Response(body, {
+    headers: response.headers,
+    status: response.status,
+    statusText: response.statusText
+  });
+}
+function after(callback) {
+  if (typeof callback !== "function") {
+    throw new TypeError("after() expects a callback function.");
+  }
+  const state = afterStorage.getStore();
+  if (!state) {
+    throw new Error("after() can only be used while Farm is handling a server request.");
+  }
+  if (state.phase === "closed") {
+    throw new Error("after() cannot schedule work after the request lifecycle has completed.");
+  }
+  let start;
+  const ready = new Promise((resolve) => {
+    start = resolve;
+  });
+  const result = ready.then(callback);
+  state.tasks.push({ result, start });
+}
+async function _runWithAfterRequest(request, handler, context) {
+  if (afterStorage.getStore()) {
+    return await handler();
+  }
+  const state = createAfterRequestState();
+  registerPlatformLifetime(state, context);
+  const hasResponseHook = registerResponseFinishedHook(state, context);
+  try {
+    const response = await afterStorage.run(state, handler);
+    return hasResponseHook ? response : wrapResponseBody(response, request, state);
+  } catch (error) {
+    finishSoon(state);
+    throw error;
+  }
+}
+async function _runWithAfterNodeResponse(response, handler, context) {
+  if (afterStorage.getStore()) {
+    return await handler();
+  }
+  const state = createAfterRequestState();
+  let finished = false;
+  const finish = () => {
+    if (finished) return;
+    finished = true;
+    response.off("finish", finish);
+    response.off("close", finish);
+    state.finishResponse();
+  };
+  response.once("finish", finish);
+  response.once("close", finish);
+  if (response.writableEnded || response.destroyed) setTimeout(finish, 0);
+  registerPlatformLifetime(state, context);
+  return await afterStorage.run(state, handler);
+}
+function _withAfterNodeMiddleware(handler) {
+  return async (request, response, next) => {
+    await _runWithAfterNodeResponse(response, () => handler(request, response, next));
+  };
+}
+
+
+
+
+
+
+exports.after = after; exports._runWithAfterRequest = _runWithAfterRequest; exports._runWithAfterNodeResponse = _runWithAfterNodeResponse; exports._withAfterNodeMiddleware = _withAfterNodeMiddleware;

package/dist/chunk-PAKCHVUS.mjs

@@ -0,0 +1,450 @@
+// src/server-components-mode.ts
+function resolveFarmServerComponentsMode(value) {
+  if (value === void 0 || value === null || value === false) return void 0;
+  if (value === true) return "rsc";
+  const mode = typeof value === "object" ? value.mode : void 0;
+  if (mode === "rsc" || mode === "islands") return mode;
+  throw new TypeError(
+    'experimental.serverComponents must be true, false, { mode: "rsc" } or { mode: "islands" }.'
+  );
+}
+function isExplicitFarmServerComponentsMode(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/dev-indicators.ts
+function resolveFarmDevIndicatorsConfig(config, mode = "development") {
+  return {
+    buildActivity: mode === "development" && (config?.buildActivity ?? true),
+    buildActivityPosition: config?.buildActivityPosition ?? "bottom-right"
+  };
+}
+function generateFarmDevIndicatorsClientRuntime(config) {
+  if (!config.buildActivity) return "";
+  const position = {
+    "bottom-right": "right: 16px; bottom: 16px;",
+    "bottom-left": "left: 16px; bottom: 16px;",
+    "top-right": "right: 16px; top: 16px;",
+    "top-left": "left: 16px; top: 16px;"
+  }[config.buildActivityPosition];
+  const styles = `
+    #__farm_build_activity__ {
+      position: fixed;
+      ${position}
+      z-index: 2147483645;
+      display: inline-flex;
+      align-items: center;
+      min-height: 34px;
+      padding: 0 11px;
+      border: 1px solid rgb(255 255 255 / 0.16);
+      border-radius: 6px;
+      background: rgb(8 8 8 / 0.94);
+      box-shadow: 0 8px 24px rgb(0 0 0 / 0.2);
+      color: rgb(250 250 250);
+      font: 500 10px/1 ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+      letter-spacing: 0;
+      opacity: 0;
+      pointer-events: none;
+      transform: translateY(4px);
+      transition: opacity 120ms ease-out, transform 120ms ease-out;
+      -webkit-backdrop-filter: blur(12px);
+      backdrop-filter: blur(12px);
+    }
+    #__farm_build_activity__[data-visible="true"] {
+      opacity: 1;
+      transform: translateY(0);
+    }
+    .farm-build-activity__brand {
+      display: inline-flex;
+      align-items: center;
+      gap: 7px;
+      flex: none;
+    }
+    .farm-build-activity__mark {
+      width: 17px;
+      height: 16px;
+      flex: none;
+    }
+    .farm-build-activity__wordmark {
+      color: rgb(255 255 255);
+      font-size: 11px;
+      font-weight: 400;
+      line-height: 1;
+    }
+    .farm-build-activity__wordmark-suffix { color: rgb(255 255 255 / 0.52); }
+    .farm-build-activity__divider {
+      width: 1px;
+      height: 14px;
+      margin: 0 9px;
+      flex: none;
+      background: rgb(255 255 255 / 0.14);
+    }
+    .farm-build-activity__loader {
+      display: grid;
+      width: 15px;
+      grid-template-columns: repeat(3, 4px);
+      gap: 1.5px;
+      flex: none;
+    }
+    .farm-build-activity__cell {
+      width: 4px;
+      height: 4px;
+      border-radius: 1px;
+      background: currentColor;
+      opacity: 0.15;
+    }
+    #__farm_build_activity__[data-state="building"] .farm-build-activity__cell {
+      animation: farm-build-activity-pixel-on 650ms ease-in-out infinite;
+    }
+    #__farm_build_activity__[data-state="building"] .farm-build-activity__cell:nth-child(1),
+    #__farm_build_activity__[data-state="building"] .farm-build-activity__cell:nth-child(5),
+    #__farm_build_activity__[data-state="building"] .farm-build-activity__cell:nth-child(7) {
+      animation-delay: 90ms;
+    }
+    #__farm_build_activity__[data-state="building"] .farm-build-activity__cell:nth-child(2),
+    #__farm_build_activity__[data-state="building"] .farm-build-activity__cell:nth-child(6),
+    #__farm_build_activity__[data-state="building"] .farm-build-activity__cell:nth-child(8) {
+      animation-delay: 180ms;
+    }
+    #__farm_build_activity__[data-state="building"] .farm-build-activity__cell:nth-child(3),
+    #__farm_build_activity__[data-state="building"] .farm-build-activity__cell:nth-child(9) {
+      animation-delay: 270ms;
+    }
+    #__farm_build_activity__[data-state="building"] .farm-build-activity__cell:nth-child(4) {
+      animation-delay: 0ms;
+    }
+    #__farm_build_activity__[data-state="ready"] .farm-build-activity__cell,
+    #__farm_build_activity__[data-state="error"] .farm-build-activity__cell {
+      opacity: 0.08;
+    }
+    #__farm_build_activity__[data-state="ready"] .farm-build-activity__cell:nth-child(3),
+    #__farm_build_activity__[data-state="ready"] .farm-build-activity__cell:nth-child(5),
+    #__farm_build_activity__[data-state="ready"] .farm-build-activity__cell:nth-child(6),
+    #__farm_build_activity__[data-state="ready"] .farm-build-activity__cell:nth-child(7),
+    #__farm_build_activity__[data-state="ready"] .farm-build-activity__cell:nth-child(8),
+    #__farm_build_activity__[data-state="error"] .farm-build-activity__cell:nth-child(1),
+    #__farm_build_activity__[data-state="error"] .farm-build-activity__cell:nth-child(3),
+    #__farm_build_activity__[data-state="error"] .farm-build-activity__cell:nth-child(5),
+    #__farm_build_activity__[data-state="error"] .farm-build-activity__cell:nth-child(7),
+    #__farm_build_activity__[data-state="error"] .farm-build-activity__cell:nth-child(9) {
+      opacity: 1;
+    }
+    .farm-build-activity__label {
+      margin-left: 7px;
+      color: rgb(255 255 255 / 0.62);
+      font-size: 9px;
+      letter-spacing: 0.06em;
+      text-transform: uppercase;
+      white-space: nowrap;
+    }
+    .farm-build-activity__sr-only {
+      position: absolute;
+      width: 1px;
+      height: 1px;
+      padding: 0;
+      margin: -1px;
+      overflow: hidden;
+      clip: rect(0, 0, 0, 0);
+      white-space: nowrap;
+      border: 0;
+    }
+    #__farm_build_activity__[data-state="error"] {
+      border-color: rgb(248 113 113 / 0.55);
+    }
+    #__farm_build_activity__[data-state="error"] .farm-build-activity__loader,
+    #__farm_build_activity__[data-state="error"] .farm-build-activity__label {
+      color: rgb(254 202 202);
+    }
+    @keyframes farm-build-activity-pixel-on {
+      0%, 32%, 100% { opacity: 0.15; }
+      14% { opacity: 1; }
+    }
+    @media (prefers-reduced-motion: reduce) {
+      #__farm_build_activity__ { transition: none; }
+      #__farm_build_activity__[data-state="building"] .farm-build-activity__cell {
+        animation: none;
+        opacity: 0.28;
+      }
+    }
+  `;
+  return `
+if (import.meta.hot) {
+  (() => {
+    const hot = import.meta.hot;
+    const indicatorId = "__farm_build_activity__";
+    const styleId = "__farm_build_activity_styles__";
+    const runtimeKey = "__FARM_BUILD_ACTIVITY_RUNTIME__";
+    const reloadMarker = "__FARM_BUILD_ACTIVITY_RELOADING__";
+    let hideTimer;
+
+    const createBrandMark = () => {
+      const namespace = "http://www.w3.org/2000/svg";
+      const mark = document.createElementNS(namespace, "svg");
+      mark.setAttribute("class", "farm-build-activity__mark");
+      mark.setAttribute("viewBox", "125 68 161 152");
+      mark.setAttribute("fill", "none");
+      mark.setAttribute("aria-hidden", "true");
+
+      const shapes = [
+        ["M157 68H133C128.582 68 125 71.5817 125 76V100C125 104.418 128.582 108 133 108H157C161.418 108 165 104.418 165 100V76C165 71.5817 161.418 68 157 68Z", "#F5F5F4"],
+        ["M182.383 68H280.617C282.045 68 283.414 68.8429 284.423 70.3431C285.433 71.8434 286 73.8783 286 76V100C286 102.122 285.433 104.157 284.423 105.657C283.414 107.157 282.045 108 280.617 108H182.383C180.955 108 179.586 107.157 178.577 105.657C177.567 104.157 177 102.122 177 100V76C177 73.8783 177.567 71.8434 178.577 70.3431C179.586 68.8429 180.955 68 182.383 68ZM271.852 81C270.747 81 269.852 81.8954 269.852 83V93C269.852 94.1046 270.747 95 271.852 95H277.272C278.376 95 279.272 94.1046 279.272 93V83C279.272 81.8954 278.376 81 277.272 81H271.852Z", "#F5F5F4"],
+        ["M157 124H133C128.582 124 125 127.582 125 132V156C125 160.418 128.582 164 133 164H157C161.418 164 165 160.418 165 156V132C165 127.582 161.418 124 157 124Z", "#A3A3A3"],
+        ["M280.334 124H182.666C179.537 124 177 127.582 177 132V156C177 160.418 179.537 164 182.666 164H280.334C283.463 164 286 160.418 286 156V132C286 127.582 283.463 124 280.334 124Z", "#A3A3A3"],
+        ["M157 180H133C128.582 180 125 183.582 125 188V212C125 216.418 128.582 220 133 220H157C161.418 220 165 216.418 165 212V188C165 183.582 161.418 180 157 180Z", "#595959"],
+        ["M230.189 180H182.811C179.602 180 177 183.582 177 188V212C177 216.418 179.602 220 182.811 220H230.189C233.398 220 236 216.418 236 212V188C236 183.582 233.398 180 230.189 180Z", "#595959"],
+      ];
+      for (const [index, [pathData, fill]] of shapes.entries()) {
+        const path = document.createElementNS(namespace, "path");
+        path.setAttribute("d", pathData);
+        path.setAttribute("fill", fill);
+        if (index === 1) {
+          path.setAttribute("fill-rule", "evenodd");
+          path.setAttribute("clip-rule", "evenodd");
+        }
+        mark.appendChild(path);
+      }
+      return mark;
+    };
+
+    const ensureIndicator = () => {
+      let style = document.getElementById(styleId);
+      if (!style) {
+        style = document.createElement("style");
+        style.id = styleId;
+        style.textContent = ${JSON.stringify(styles)};
+        document.head.appendChild(style);
+      }
+
+      let indicator = document.getElementById(indicatorId);
+      if (!indicator) {
+        indicator = document.createElement("div");
+        indicator.id = indicatorId;
+        indicator.setAttribute("role", "status");
+        indicator.setAttribute("aria-live", "polite");
+
+        const brand = document.createElement("span");
+        brand.className = "farm-build-activity__brand";
+        brand.setAttribute("aria-hidden", "true");
+        const wordmark = document.createElement("span");
+        wordmark.className = "farm-build-activity__wordmark";
+        const suffix = document.createElement("span");
+        suffix.className = "farm-build-activity__wordmark-suffix";
+        suffix.textContent = ".JS";
+        wordmark.append("FARM", suffix);
+        brand.append(createBrandMark(), wordmark);
+
+        const divider = document.createElement("span");
+        divider.className = "farm-build-activity__divider";
+        divider.setAttribute("aria-hidden", "true");
+
+        const loader = document.createElement("span");
+        loader.className = "farm-build-activity__loader";
+        loader.setAttribute("aria-hidden", "true");
+        for (let index = 0; index < 9; index += 1) {
+          const cell = document.createElement("span");
+          cell.className = "farm-build-activity__cell";
+          loader.appendChild(cell);
+        }
+
+        const label = document.createElement("span");
+        label.className = "farm-build-activity__label";
+        label.setAttribute("aria-hidden", "true");
+        label.dataset.farmBuildLabel = "";
+        const message = document.createElement("span");
+        message.className = "farm-build-activity__sr-only";
+        message.dataset.farmBuildMessage = "";
+        indicator.append(loader, label, divider, brand, message);
+        document.body.appendChild(indicator);
+      }
+      return indicator;
+    };
+
+    const show = (state, label, message) => {
+      window.clearTimeout(hideTimer);
+      const indicator = ensureIndicator();
+      indicator.dataset.state = state;
+      indicator.dataset.visible = "true";
+      indicator.querySelector("[data-farm-build-label]").textContent = label;
+      indicator.querySelector("[data-farm-build-message]").textContent = message;
+    };
+    const hide = () => {
+      const indicator = document.getElementById(indicatorId);
+      if (indicator) indicator.dataset.visible = "false";
+    };
+    const onBeforeUpdate = () => show("building", "Updating", "Farm.js updating");
+    const onAfterUpdate = () => {
+      show("ready", "Ready", "Farm.js ready");
+      hideTimer = window.setTimeout(hide, 500);
+    };
+    const onError = () => show("error", "Build failed", "Farm.js build failed");
+    const onBeforeFullReload = () => {
+      try {
+        window.sessionStorage.setItem(reloadMarker, "1");
+      } catch {}
+      show("building", "Updating", "Farm.js updating");
+    };
+
+    window[runtimeKey]?.dispose?.();
+    ensureIndicator();
+    let completedReload = false;
+    try {
+      completedReload = window.sessionStorage.getItem(reloadMarker) === "1";
+      window.sessionStorage.removeItem(reloadMarker);
+    } catch {}
+    if (completedReload) onAfterUpdate();
+    else hide();
+    hot.on("vite:beforeUpdate", onBeforeUpdate);
+    hot.on("vite:afterUpdate", onAfterUpdate);
+    hot.on("vite:error", onError);
+    hot.on("vite:beforeFullReload", onBeforeFullReload);
+    window[runtimeKey] = {
+      dispose() {
+        window.clearTimeout(hideTimer);
+        hot.off("vite:beforeUpdate", onBeforeUpdate);
+        hot.off("vite:afterUpdate", onAfterUpdate);
+        hot.off("vite:error", onError);
+        hot.off("vite:beforeFullReload", onBeforeFullReload);
+        document.getElementById(indicatorId)?.remove();
+      },
+    };
+  })();
+}
+`;
+}
+
+// src/utils/source-dir.ts
+import path from "path";
+var FARM_PROJECT_SOURCE_DIRS = /* @__PURE__ */ Symbol.for("farm.projectSourceDirs");
+function getProjectSourceDirs() {
+  const globalState = globalThis;
+  return globalState[FARM_PROJECT_SOURCE_DIRS] ?? (globalState[FARM_PROJECT_SOURCE_DIRS] = /* @__PURE__ */ new Map());
+}
+function setFarmProjectSourceDir(root, srcDir) {
+  getProjectSourceDirs().set(path.resolve(root), srcDir);
+}
+function getFarmProjectSourceDir(root) {
+  return getProjectSourceDirs().get(path.resolve(root)) ?? "src";
+}
+
+// src/auth-config.ts
+import { createRequire } from "module";
+import path2 from "path";
+import { pathToFileURL } from "url";
+function resolveFarmAuthConfig(input) {
+  const config = input === true ? {} : input && typeof input === "object" ? input : {};
+  const passwordConfig = typeof config.emailAndPassword === "object" ? config.emailAndPassword : {};
+  const resolved = {
+    enabled: input !== void 0 && input !== false && config.enabled !== false,
+    appName: config.appName,
+    basePath: normalizeBasePath(config.basePath),
+    emailAndPassword: {
+      enabled: config.emailAndPassword !== false,
+      requireEmailVerification: passwordConfig.requireEmailVerification ?? false,
+      minPasswordLength: passwordConfig.minPasswordLength ?? 8,
+      maxPasswordLength: passwordConfig.maxPasswordLength ?? 128
+    },
+    session: {
+      expiresIn: config.session?.expiresIn ?? 60 * 60 * 24 * 7,
+      updateAge: config.session?.updateAge ?? 60 * 60 * 24
+    },
+    database: {
+      url: config.database?.url,
+      path: config.database?.path || ".farm/auth.sqlite",
+      migrateInDevelopment: config.database?.migrateInDevelopment ?? true
+    }
+  };
+  validateFarmAuthConfig(resolved);
+  return resolved;
+}
+async function resolveFarmAuthIntegration(config, options) {
+  if (!config.enabled) return void 0;
+  const root = path2.resolve(options.root);
+  let modulePath;
+  try {
+    const resolveFromApp = createRequire(path2.join(root, "package.json"));
+    modulePath = resolveFromApp.resolve("@farm.js/auth/internal");
+  } catch {
+    throw new Error(
+      "The `auth` config requires @farm.js/auth. Install it with `pnpm add @farm.js/auth` and try again."
+    );
+  }
+  const runtime = await import(
+    /* @vite-ignore */
+    pathToFileURL(modulePath).href
+  );
+  if (typeof runtime.createFarmAuthIntegration !== "function") {
+    throw new Error(
+      "The installed @farm.js/auth package is incompatible with this version of @farm.js/core."
+    );
+  }
+  return runtime.createFarmAuthIntegration(config, {
+    ...options,
+    root
+  });
+}
+function normalizeBasePath(value) {
+  const route = (value || "/api/auth").trim();
+  if (!route) return "/api/auth";
+  assertStableBasePath(route);
+  const withLeadingSlash = route.startsWith("/") ? route : `/${route}`;
+  const normalized = withLeadingSlash.replace(/\/+/g, "/").replace(/\/+$/, "");
+  return normalized || "/api/auth";
+}
+function assertStableBasePath(route) {
+  if (route.includes("?") || route.includes("#")) {
+    throw new Error("auth.basePath cannot contain a query string or fragment.");
+  }
+  if (route.startsWith("//") || /^[a-z][a-z\d+.-]*:\/\//i.test(route)) {
+    throw new Error('auth.basePath must be an application pathname such as "/api/auth".');
+  }
+  if (hasUnstablePathCharacters(route)) {
+    throw new Error("auth.basePath cannot contain backslashes or control characters.");
+  }
+  for (const segment of route.split("/")) {
+    let decoded = segment;
+    try {
+      decoded = decodeURIComponent(segment);
+    } catch {
+    }
+    if (hasUnstablePathCharacters(decoded) || decoded.includes("/")) {
+      throw new Error("auth.basePath cannot contain encoded path separators.");
+    }
+    if (decoded === "." || decoded === "..") {
+      throw new Error('auth.basePath cannot contain "." or ".." path segments.');
+    }
+  }
+}
+function hasUnstablePathCharacters(value) {
+  return value.includes("\\") || Array.from(value).some((character) => {
+    const code = character.charCodeAt(0);
+    return code <= 31 || code >= 127 && code <= 159;
+  });
+}
+function validateFarmAuthConfig(config) {
+  const { minPasswordLength, maxPasswordLength } = config.emailAndPassword;
+  if (!Number.isInteger(minPasswordLength) || minPasswordLength < 1) {
+    throw new Error("auth.emailAndPassword.minPasswordLength must be a positive integer.");
+  }
+  if (!Number.isInteger(maxPasswordLength) || maxPasswordLength < minPasswordLength) {
+    throw new Error(
+      "auth.emailAndPassword.maxPasswordLength must be an integer greater than or equal to minPasswordLength."
+    );
+  }
+  if (!Number.isInteger(config.session.expiresIn) || config.session.expiresIn < 1) {
+    throw new Error("auth.session.expiresIn must be a positive integer.");
+  }
+  if (!Number.isInteger(config.session.updateAge) || config.session.updateAge < 0) {
+    throw new Error("auth.session.updateAge must be a non-negative integer.");
+  }
+}
+
+export {
+  resolveFarmServerComponentsMode,
+  isExplicitFarmServerComponentsMode,
+  setFarmProjectSourceDir,
+  getFarmProjectSourceDir,
+  resolveFarmDevIndicatorsConfig,
+  generateFarmDevIndicatorsClientRuntime,
+  resolveFarmAuthConfig,
+  resolveFarmAuthIntegration
+};