@farm.js/core 0.1.51-beta.3 → 0.1.61

package/dist/chunk-BUGNQIHC.mjs

@@ -0,0 +1,449 @@
+import {
+  bundleNodeModule,
+  isDeclarationFile,
+  resolvePackageWithoutTsconfig
+} from "./chunk-SFGWNC43.mjs";
+import {
+  __name
+} from "./chunk-LPEX4YW6.mjs";
+
+// src/layers.ts
+import { existsSync, readFileSync, realpathSync, statSync } from "fs";
+import { mkdir, unlink } from "fs/promises";
+import { createRequire, isBuiltin } from "module";
+import path from "path";
+import { pathToFileURL } from "url";
+var FARM_CORE_PACKAGE = "@farm.js/core";
+var FARM_CONFIG_ENTRY = "@farm.js/core/config";
+var FARM_CORE_REFERENCE_RE = /(["'])@farm.js\/core\1/g;
+var FARM_CONFIG_HELPER_IMPORT_RE = /(?:^|\n)[\t ]*import[\t ]*\{([^{}]*)\}[\t ]*from[\t ]*(["'])@farm.js\/core\2[\t ]*;?[\t ]*(?:\n|$)/g;
+var FARM_CONFIG_HELPER_SPECIFIER_RE = /^(?:defineConfig|defineFarmConfig)(?:\s+as\s+[$A-Z_a-z][$\w]*)?$/;
+var CONFIG_FILENAMES = [
+  "farm.config.ts",
+  "farm.config.tsx",
+  "farm.config.mts",
+  "farm.config.cts",
+  "farm.config.js",
+  "farm.config.jsx",
+  "farm.config.mjs",
+  "farm.config.cjs",
+  "config.ts",
+  "config.tsx",
+  "config.mts",
+  "config.cts",
+  "config.js",
+  "config.jsx",
+  "config.mjs",
+  "config.cjs"
+];
+var LAYER_LOCAL_CONFIG_KEYS = /* @__PURE__ */ new Set([
+  "root",
+  "srcDir",
+  "outDir",
+  "distDir",
+  "deploy",
+  "output",
+  "preset",
+  "publicDir",
+  "generateBuildId"
+]);
+async function resolveFarmLayers(projectConfig, options) {
+  const projectRoot = path.resolve(options.root);
+  const entries = normalizeLayerEntries(projectConfig.extends, "project config");
+  if (entries.length === 0) {
+    return {
+      config: {
+        ...projectConfig,
+        layers: []
+      },
+      layers: []
+    };
+  }
+  const loadedLayers = [];
+  const visited = /* @__PURE__ */ new Set();
+  const aliases = /* @__PURE__ */ new Map();
+  const visit = /* @__PURE__ */ __name(async (source, ownerRoot, stack) => {
+    const resolvedSource = resolveLayerSource(source, ownerRoot);
+    const cycleIndex = stack.findIndex((entry) => entry.root === resolvedSource.root);
+    if (cycleIndex !== -1) {
+      const cycle = [...stack.slice(cycleIndex).map((entry) => entry.source), source];
+      throw new Error(`Farm layer cycle detected: ${cycle.join(" -> ")}`);
+    }
+    if (visited.has(resolvedSource.root)) return;
+    const configFile = findFarmConfigFile(resolvedSource.root, resolvedSource.configFile);
+    const config = configFile ? await loadFarmConfigFile(configFile, {
+      cacheRoot: projectRoot,
+      root: resolvedSource.root
+    }) : {};
+    const nestedEntries = normalizeLayerEntries(config.extends, `layer ${JSON.stringify(source)}`);
+    const nextStack = [...stack, { root: resolvedSource.root, source }];
+    for (const nestedSource of nestedEntries) {
+      await visit(nestedSource, resolvedSource.root, nextStack);
+    }
+    if (visited.has(resolvedSource.root)) return;
+    const name = getLayerName(source, resolvedSource.root);
+    const conflictingRoot = aliases.get(name);
+    if (conflictingRoot && conflictingRoot !== resolvedSource.root) {
+      throw new Error(
+        `Farm layer alias "#layers/${name}" is ambiguous between ${conflictingRoot} and ${resolvedSource.root}`
+      );
+    }
+    aliases.set(name, resolvedSource.root);
+    visited.add(resolvedSource.root);
+    loadedLayers.push({
+      source,
+      name,
+      root: resolvedSource.root,
+      srcDir: normalizeLayerSrcDir(config.srcDir),
+      configFile,
+      config
+    });
+  }, "visit");
+  for (const source of entries) {
+    await visit(source, projectRoot, []);
+  }
+  let mergedConfig = {};
+  for (const layer of loadedLayers) {
+    mergedConfig = mergeFarmLayerConfig(mergedConfig, getLayerDefaults(layer.config));
+  }
+  mergedConfig = mergeFarmLayerConfig(mergedConfig, projectConfig);
+  const layers = loadedLayers.map(({ config: _config, ...layer }) => layer);
+  return {
+    config: {
+      ...mergedConfig,
+      root: projectConfig.root,
+      srcDir: projectConfig.srcDir,
+      extends: projectConfig.extends,
+      layers
+    },
+    layers
+  };
+}
+__name(resolveFarmLayers, "resolveFarmLayers");
+function getFarmSourceRoots(config) {
+  const roots = (config.layers ?? []).map((layer) => ({
+    name: layer.name,
+    root: layer.root,
+    srcDir: layer.srcDir,
+    layer: true
+  }));
+  roots.push({
+    name: "project",
+    root: path.resolve(config.root || process.cwd()),
+    srcDir: config.srcDir || "src",
+    layer: false
+  });
+  return roots;
+}
+__name(getFarmSourceRoots, "getFarmSourceRoots");
+function getFarmAppDirectories(config) {
+  return getFarmSourceRoots(config).map((source) => path.join(source.root, source.srcDir, "app"));
+}
+__name(getFarmAppDirectories, "getFarmAppDirectories");
+function getFarmLayerAliases(layers) {
+  return Object.fromEntries(
+    (layers ?? []).map((layer) => [`#layers/${layer.name}`, path.join(layer.root, layer.srcDir)])
+  );
+}
+__name(getFarmLayerAliases, "getFarmLayerAliases");
+var WINDOWS_ABSOLUTE_PATH_RE = /^(?:[A-Za-z]:[\\/]|\\\\)/;
+function toExternalSpecifier(resolvedPath) {
+  return path.isAbsolute(resolvedPath) ? pathToFileURL(resolvedPath).href : resolvedPath;
+}
+__name(toExternalSpecifier, "toExternalSpecifier");
+var BARE_SPECIFIER_RE = /^[^./]/;
+function createFarmConfigResolutionPlugin(options) {
+  const configEntryChecks = /* @__PURE__ */ new Map();
+  return {
+    name: "farm-config-package-resolution",
+    async resolveId(source, importer, extraOptions) {
+      if (!importer || extraOptions.isEntry || !BARE_SPECIFIER_RE.test(source) || source.startsWith("\0") || isBuiltin(source) || path.isAbsolute(source) || WINDOWS_ABSOLUTE_PATH_RE.test(source)) {
+        return null;
+      }
+      const resolveRuntimePath = /* @__PURE__ */ __name(async (specifier) => {
+        const resolved = await this.resolve(specifier, importer, {
+          kind: extraOptions.kind,
+          skipSelf: true
+        });
+        if (!resolved?.id || !isDeclarationFile(resolved.id)) return resolved?.id;
+        return await resolvePackageWithoutTsconfig(specifier, importer, extraOptions.kind) ?? void 0;
+      }, "resolveRuntimePath");
+      if (source === FARM_CORE_PACKAGE && extraOptions.kind === "import-statement") {
+        let configEntryCheck = configEntryChecks.get(importer);
+        if (!configEntryCheck) {
+          configEntryCheck = onlyImportsFarmConfigHelpers(importer, options.transform);
+          configEntryChecks.set(importer, configEntryCheck);
+        }
+        if (await configEntryCheck) {
+          const configEntry = await resolveRuntimePath(FARM_CONFIG_ENTRY);
+          if (configEntry) {
+            return { id: toExternalSpecifier(configEntry), external: true };
+          }
+        }
+      }
+      const resolvedId = await resolveRuntimePath(source);
+      if (!resolvedId) {
+        return { id: source, external: true };
+      }
+      return { id: toExternalSpecifier(resolvedId), external: true };
+    }
+  };
+}
+__name(createFarmConfigResolutionPlugin, "createFarmConfigResolutionPlugin");
+var FARM_CONFIG_ROOT = /* @__PURE__ */ Symbol.for("farm.configRoot");
+async function loadFarmConfigFile(configPath, options) {
+  const { transform } = await import("rolldown/utils");
+  const cacheRoot = path.resolve(options.cacheRoot || options.root);
+  const configCacheDir = path.join(cacheRoot, ".farm", ".config-loader");
+  await mkdir(configCacheDir, { recursive: true });
+  const modulePath = path.join(
+    configCacheDir,
+    `farm-config-${Date.now()}-${Math.random().toString(36).slice(2)}.mjs`
+  );
+  await bundleNodeModule({
+    root: path.resolve(options.root),
+    entry: path.resolve(configPath),
+    outfile: modulePath,
+    target: `node${process.versions.node.split(".")[0]}`,
+    plugins: [createFarmConfigResolutionPlugin({ transform })]
+  });
+  const moduleUrl = `${pathToFileURL(modulePath).href}?t=${Date.now()}`;
+  const configRootState = globalThis;
+  const previousConfigRoot = configRootState[FARM_CONFIG_ROOT];
+  configRootState[FARM_CONFIG_ROOT] = cacheRoot;
+  try {
+    const loaded = await import(
+      /* @vite-ignore */
+      moduleUrl
+    );
+    const config = loaded.default || loaded;
+    if (!config || typeof config !== "object" || Array.isArray(config)) {
+      throw new TypeError(`Farm config ${configPath} must export an object`);
+    }
+    return config;
+  } finally {
+    configRootState[FARM_CONFIG_ROOT] = previousConfigRoot;
+    await unlink(modulePath).catch(() => void 0);
+  }
+}
+__name(loadFarmConfigFile, "loadFarmConfigFile");
+async function onlyImportsFarmConfigHelpers(importer, transform) {
+  try {
+    const source = readFileSync(importer, "utf8");
+    if (!source.includes(FARM_CORE_PACKAGE)) return false;
+    const transformed = await transform(importer, source, {
+      lang: getSourceLang(importer),
+      sourceType: "module",
+      jsx: { runtime: "automatic" }
+    });
+    if (transformed.errors.length > 0) return false;
+    const references = [...transformed.code.matchAll(FARM_CORE_REFERENCE_RE)];
+    if (references.length === 0) return false;
+    const safeImportRanges = [];
+    for (const match of transformed.code.matchAll(FARM_CONFIG_HELPER_IMPORT_RE)) {
+      const specifiers = match[1].split(",").map((specifier) => specifier.trim()).filter(Boolean);
+      if (specifiers.length === 0 || !specifiers.every((specifier) => FARM_CONFIG_HELPER_SPECIFIER_RE.test(specifier))) {
+        continue;
+      }
+      const start = match.index ?? 0;
+      safeImportRanges.push({ start, end: start + match[0].length });
+    }
+    return references.every((reference) => {
+      const index = reference.index ?? -1;
+      return safeImportRanges.some((range) => index >= range.start && index < range.end);
+    });
+  } catch {
+    return false;
+  }
+}
+__name(onlyImportsFarmConfigHelpers, "onlyImportsFarmConfigHelpers");
+function getSourceLang(file) {
+  switch (path.extname(file)) {
+    case ".ts":
+    case ".mts":
+    case ".cts":
+      return "ts";
+    case ".tsx":
+      return "tsx";
+    case ".jsx":
+      return "jsx";
+    default:
+      return "js";
+  }
+}
+__name(getSourceLang, "getSourceLang");
+function normalizeLayerEntries(value, owner) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value)) {
+    throw new TypeError(`${owner} "extends" must be an array of layer paths or package names`);
+  }
+  return value.map((entry, index) => {
+    if (typeof entry !== "string" || entry.trim() === "") {
+      throw new TypeError(`${owner} "extends" entry ${index} must be a non-empty string`);
+    }
+    return entry.trim();
+  });
+}
+__name(normalizeLayerEntries, "normalizeLayerEntries");
+function resolveLayerSource(source, ownerRoot) {
+  if (isPathLayerSource(source)) {
+    const target = source.startsWith("file:") ? path.resolve(ownerRoot, source.slice("file:".length)) : path.resolve(ownerRoot, source);
+    if (!existsSync(target)) {
+      throw new Error(`Cannot resolve Farm layer ${JSON.stringify(source)} from ${ownerRoot}`);
+    }
+    const stats = statSync(target);
+    const root = stats.isDirectory() ? target : path.dirname(target);
+    return {
+      root: normalizeRealPath(root),
+      configFile: stats.isFile() ? normalizeRealPath(target) : void 0
+    };
+  }
+  const requireFromOwner = createRequire(path.join(ownerRoot, "package.json"));
+  let packageJsonPath;
+  try {
+    packageJsonPath = requireFromOwner.resolve(`${source}/package.json`);
+  } catch {
+  }
+  if (packageJsonPath) {
+    return { root: normalizeRealPath(path.dirname(packageJsonPath)) };
+  }
+  try {
+    const entryPath = requireFromOwner.resolve(source);
+    const packageRoot = findNearestPackageRoot(entryPath);
+    if (packageRoot) return { root: normalizeRealPath(packageRoot) };
+  } catch {
+  }
+  throw new Error(`Cannot resolve Farm layer package ${JSON.stringify(source)} from ${ownerRoot}`);
+}
+__name(resolveLayerSource, "resolveLayerSource");
+function findNearestPackageRoot(entryPath) {
+  let current = statSync(entryPath).isDirectory() ? entryPath : path.dirname(entryPath);
+  while (true) {
+    if (existsSync(path.join(current, "package.json"))) return current;
+    const parent = path.dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+__name(findNearestPackageRoot, "findNearestPackageRoot");
+function findFarmConfigFile(root, explicitPath) {
+  if (explicitPath) return explicitPath;
+  for (const fileName of CONFIG_FILENAMES) {
+    const candidate = path.join(root, fileName);
+    if (existsSync(candidate)) return candidate;
+  }
+  return void 0;
+}
+__name(findFarmConfigFile, "findFarmConfigFile");
+function getLayerName(source, root) {
+  if (!isPathLayerSource(source)) {
+    const packageName = source.split("/").filter(Boolean).pop();
+    if (packageName) return sanitizeLayerName(packageName);
+  }
+  try {
+    const packageJson = JSON.parse(readFileSync(path.join(root, "package.json"), "utf8"));
+    if (typeof packageJson.name === "string") {
+      return sanitizeLayerName(packageJson.name.split("/").pop() || packageJson.name);
+    }
+  } catch {
+  }
+  return sanitizeLayerName(path.basename(root));
+}
+__name(getLayerName, "getLayerName");
+function sanitizeLayerName(value) {
+  const name = value.trim().replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/^-+|-+$/g, "");
+  if (!name) throw new Error(`Cannot derive a name for Farm layer ${JSON.stringify(value)}`);
+  return name;
+}
+__name(sanitizeLayerName, "sanitizeLayerName");
+function normalizeLayerSrcDir(value) {
+  if (value === void 0) return "src";
+  if (typeof value !== "string" || value.trim() === "" || path.isAbsolute(value)) {
+    throw new TypeError("A Farm layer srcDir must be a non-empty relative path");
+  }
+  const normalized = path.normalize(value.trim());
+  if (normalized === ".." || normalized.startsWith(`..${path.sep}`)) {
+    throw new TypeError("A Farm layer srcDir cannot leave the layer root");
+  }
+  return normalized;
+}
+__name(normalizeLayerSrcDir, "normalizeLayerSrcDir");
+function getLayerDefaults(config) {
+  return Object.fromEntries(
+    Object.entries(config).filter(
+      ([key, value]) => key !== "extends" && value !== void 0 && !LAYER_LOCAL_CONFIG_KEYS.has(key)
+    )
+  );
+}
+__name(getLayerDefaults, "getLayerDefaults");
+function mergeFarmLayerConfig(base, override) {
+  const output = { ...base };
+  for (const [key, value] of Object.entries(override)) {
+    if (value === void 0 || key === "layers") continue;
+    if (key === "plugins") {
+      output[key] = [...toArray(output[key]), ...toArray(value)];
+      continue;
+    }
+    if (key === "middleware" && output[key] !== void 0) {
+      output[key] = [...toArray(output[key]), ...toArray(value)];
+      continue;
+    }
+    if ((key === "redirects" || key === "rewrites" || key === "headers") && output[key]) {
+      output[key] = mergeConfigListResolvers(output[key], value);
+      continue;
+    }
+    if (isPlainObject(output[key]) && isPlainObject(value)) {
+      output[key] = mergePlainObjects(output[key], value);
+      continue;
+    }
+    output[key] = value;
+  }
+  return output;
+}
+__name(mergeFarmLayerConfig, "mergeFarmLayerConfig");
+function mergePlainObjects(base, override) {
+  const output = { ...base };
+  for (const [key, value] of Object.entries(override)) {
+    if (value === void 0) continue;
+    output[key] = isPlainObject(output[key]) && isPlainObject(value) ? mergePlainObjects(output[key], value) : value;
+  }
+  return output;
+}
+__name(mergePlainObjects, "mergePlainObjects");
+function mergeConfigListResolvers(base, override) {
+  return async () => [...await resolveConfigList(base), ...await resolveConfigList(override)];
+}
+__name(mergeConfigListResolvers, "mergeConfigListResolvers");
+async function resolveConfigList(value) {
+  const resolved = typeof value === "function" ? await value() : value;
+  return toArray(resolved);
+}
+__name(resolveConfigList, "resolveConfigList");
+function toArray(value) {
+  if (value === void 0 || value === null) return [];
+  return Array.isArray(value) ? value : [value];
+}
+__name(toArray, "toArray");
+function isPlainObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+__name(isPlainObject, "isPlainObject");
+function isPathLayerSource(source) {
+  return source.startsWith(".") || source.startsWith("/") || source.startsWith("file:") || /^[a-zA-Z]:[\\/]/.test(source);
+}
+__name(isPathLayerSource, "isPathLayerSource");
+function normalizeRealPath(value) {
+  return path.resolve(realpathSync(value));
+}
+__name(normalizeRealPath, "normalizeRealPath");
+
+export {
+  resolveFarmLayers,
+  getFarmSourceRoots,
+  getFarmAppDirectories,
+  getFarmLayerAliases,
+  createFarmConfigResolutionPlugin,
+  loadFarmConfigFile
+};

package/dist/chunk-C4NCTZLM.mjs

@@ -0,0 +1,22 @@
+import {
+  __name
+} from "./chunk-LPEX4YW6.mjs";
+
+// src/i18n/bridge.ts
+var FARM_I18N_SNAPSHOT_RESOLVER = /* @__PURE__ */ Symbol.for("farm.i18n.snapshotResolver");
+function _setFarmI18nSnapshotResolver(resolver) {
+  globalThis[FARM_I18N_SNAPSHOT_RESOLVER] = resolver;
+}
+__name(_setFarmI18nSnapshotResolver, "_setFarmI18nSnapshotResolver");
+function getActiveFarmI18nSnapshot() {
+  if (typeof window !== "undefined" && window.__FARM_I18N__) {
+    return window.__FARM_I18N__;
+  }
+  return globalThis[FARM_I18N_SNAPSHOT_RESOLVER]?.();
+}
+__name(getActiveFarmI18nSnapshot, "getActiveFarmI18nSnapshot");
+
+export {
+  _setFarmI18nSnapshotResolver,
+  getActiveFarmI18nSnapshot
+};

package/dist/chunk-C4SPBWFM.cjs

@@ -0,0 +1,26 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/client/navigation-url.ts
+var FARM_NAVIGATION_PROTOCOLS = /* @__PURE__ */ new Set(["http:", "https:", "mailto:", "tel:"]);
+function isFarmBlockedNavigationURL(url) {
+  if (FARM_NAVIGATION_PROTOCOLS.has(url.protocol)) return false;
+  console.error(`[Farm.js] Blocked navigation to a ${url.protocol} URL as a security precaution.`);
+  return true;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isFarmBlockedNavigationURL, "isFarmBlockedNavigationURL");
+function isFarmExternalNavigationURL(url, currentOrigin) {
+  return url.protocol !== "http:" && url.protocol !== "https:" || url.origin !== currentOrigin;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isFarmExternalNavigationURL, "isFarmExternalNavigationURL");
+function resolveFarmNavigationURL(href, documentUrl) {
+  return new URL(href, documentUrl);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveFarmNavigationURL, "resolveFarmNavigationURL");
+
+
+
+
+
+exports.isFarmBlockedNavigationURL = isFarmBlockedNavigationURL; exports.isFarmExternalNavigationURL = isFarmExternalNavigationURL; exports.resolveFarmNavigationURL = resolveFarmNavigationURL;

package/dist/chunk-C5GUTBZK.cjs

@@ -0,0 +1,173 @@
+"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 _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/deployment.ts
+var FARM_DEPLOYMENT_ID_HEADER = "x-farm-deployment-id";
+var FARM_DEPLOYMENT_MISMATCH_HEADER = "x-farm-deployment-mismatch";
+var FARM_DEPLOYMENT_COOKIE = "__farm_deployment";
+var FARM_DEPLOYMENT_MISMATCH_CODE = "FARM_DEPLOYMENT_MISMATCH";
+var FARM_DEPLOYMENT_MISMATCH_STATUS = 409;
+function getFarmPresetRuntime(preset) {
+  if (preset === "cloudflare" || preset === "cloudflare-pages" || preset === "cloudflare-module" || preset === "netlify-edge" || preset === "vercel-edge" || preset === "deno") {
+    return "edge";
+  }
+  if (preset === "node-server" || preset === "vercel" || preset === "netlify" || preset === "aws-lambda" || preset === "azure" || preset === "firebase" || preset === "bun" || preset === "self-host" || preset === "farm") {
+    return "node";
+  }
+  return "unknown";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getFarmPresetRuntime, "getFarmPresetRuntime");
+var _FarmDeploymentMismatchError = class _FarmDeploymentMismatchError extends Error {
+  constructor(clientDeploymentId, serverDeploymentId) {
+    super("The application was updated while this page was open. Refresh before trying again.");
+    this.clientDeploymentId = clientDeploymentId;
+    this.serverDeploymentId = serverDeploymentId;
+    this.name = "FarmDeploymentMismatchError";
+    this.code = FARM_DEPLOYMENT_MISMATCH_CODE;
+    this.retryable = false;
+  }
+};
+_chunkS3JO3N4Hcjs.__name.call(void 0, _FarmDeploymentMismatchError, "FarmDeploymentMismatchError");
+var FarmDeploymentMismatchError = _FarmDeploymentMismatchError;
+function normalizeFarmDeploymentId(value) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new TypeError("Farm deploymentId must be a non-empty string");
+  }
+  const normalized = value.trim();
+  if (normalized.length > 200 || /[\u0000-\u001f\u007f]/.test(normalized)) {
+    throw new TypeError("Farm deploymentId must be at most 200 characters without control bytes");
+  }
+  return normalized;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeFarmDeploymentId, "normalizeFarmDeploymentId");
+function createFarmDeploymentRequestHeaders(deploymentId, init) {
+  const headers = new Headers(init);
+  if (deploymentId) {
+    headers.set(FARM_DEPLOYMENT_ID_HEADER, deploymentId);
+  }
+  return headers;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createFarmDeploymentRequestHeaders, "createFarmDeploymentRequestHeaders");
+function getFarmRequestDeploymentId(request) {
+  const headerValue = _optionalChain([request, 'access', _ => _.headers, 'access', _2 => _2.get, 'call', _3 => _3(FARM_DEPLOYMENT_ID_HEADER), 'optionalAccess', _4 => _4.trim, 'call', _5 => _5()]);
+  if (headerValue) return headerValue;
+  if (isSafeRequestMethod(request.method)) return void 0;
+  return readCookie(request.headers.get("cookie"), FARM_DEPLOYMENT_COOKIE);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getFarmRequestDeploymentId, "getFarmRequestDeploymentId");
+function getFarmDeploymentMismatch(request, serverDeploymentId) {
+  if (!serverDeploymentId) return null;
+  const clientDeploymentId = getFarmRequestDeploymentId(request);
+  if (!clientDeploymentId || clientDeploymentId === serverDeploymentId) return null;
+  return { clientDeploymentId, serverDeploymentId };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getFarmDeploymentMismatch, "getFarmDeploymentMismatch");
+function createFarmDeploymentMismatchResponse(mismatch) {
+  return new Response(
+    JSON.stringify({
+      error: FARM_DEPLOYMENT_MISMATCH_CODE,
+      message: "The application deployment changed. Refresh before retrying this request."
+    }),
+    {
+      status: FARM_DEPLOYMENT_MISMATCH_STATUS,
+      headers: {
+        "Cache-Control": "no-store",
+        "Content-Type": "application/json; charset=utf-8",
+        [FARM_DEPLOYMENT_ID_HEADER]: mismatch.serverDeploymentId,
+        [FARM_DEPLOYMENT_MISMATCH_HEADER]: "1"
+      }
+    }
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createFarmDeploymentMismatchResponse, "createFarmDeploymentMismatchResponse");
+function withFarmDeploymentResponse(response, deploymentId, options = {}) {
+  if (!deploymentId) return response;
+  const headers = new Headers(response.headers);
+  headers.set(FARM_DEPLOYMENT_ID_HEADER, deploymentId);
+  if (options.setCookie) {
+    headers.append(
+      "Set-Cookie",
+      createFarmDeploymentCookie(
+        deploymentId,
+        _nullishCoalesce(options.cookiePath, () => ( "/")),
+        _nullishCoalesce(options.secureCookie, () => ( false))
+      )
+    );
+  }
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, withFarmDeploymentResponse, "withFarmDeploymentResponse");
+function getFarmResponseDeploymentId(response) {
+  return _optionalChain([response, 'access', _6 => _6.headers, 'access', _7 => _7.get, 'call', _8 => _8(FARM_DEPLOYMENT_ID_HEADER), 'optionalAccess', _9 => _9.trim, 'call', _10 => _10()]) || void 0;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getFarmResponseDeploymentId, "getFarmResponseDeploymentId");
+function isFarmDeploymentMismatchResponse(response, clientDeploymentId) {
+  const serverDeploymentId = getFarmResponseDeploymentId(response);
+  if (clientDeploymentId && serverDeploymentId && clientDeploymentId !== serverDeploymentId) {
+    return true;
+  }
+  return response.status === FARM_DEPLOYMENT_MISMATCH_STATUS && response.headers.get(FARM_DEPLOYMENT_MISMATCH_HEADER) === "1";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isFarmDeploymentMismatchResponse, "isFarmDeploymentMismatchResponse");
+function createFarmDeploymentMismatchError(response, clientDeploymentId) {
+  return new FarmDeploymentMismatchError(
+    clientDeploymentId,
+    getFarmResponseDeploymentId(response) || "unknown"
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createFarmDeploymentMismatchError, "createFarmDeploymentMismatchError");
+function createFarmDeploymentCookie(deploymentId, path = "/", secure = false) {
+  const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+  return [
+    `${FARM_DEPLOYMENT_COOKIE}=${encodeURIComponent(deploymentId)}`,
+    `Path=${normalizedPath}`,
+    "HttpOnly",
+    "SameSite=Lax",
+    secure ? "Secure" : ""
+  ].filter(Boolean).join("; ");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createFarmDeploymentCookie, "createFarmDeploymentCookie");
+function readCookie(cookieHeader, name) {
+  if (!cookieHeader) return void 0;
+  for (const part of cookieHeader.split(";")) {
+    const separator = part.indexOf("=");
+    if (separator === -1 || part.slice(0, separator).trim() !== name) continue;
+    const value = part.slice(separator + 1).trim();
+    try {
+      return decodeURIComponent(value);
+    } catch (e) {
+      return value;
+    }
+  }
+  return void 0;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, readCookie, "readCookie");
+function isSafeRequestMethod(method) {
+  return ["GET", "HEAD", "OPTIONS", "QUERY"].includes(method.toUpperCase());
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isSafeRequestMethod, "isSafeRequestMethod");
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.FARM_DEPLOYMENT_ID_HEADER = FARM_DEPLOYMENT_ID_HEADER; exports.FARM_DEPLOYMENT_MISMATCH_HEADER = FARM_DEPLOYMENT_MISMATCH_HEADER; exports.FARM_DEPLOYMENT_COOKIE = FARM_DEPLOYMENT_COOKIE; exports.FARM_DEPLOYMENT_MISMATCH_CODE = FARM_DEPLOYMENT_MISMATCH_CODE; exports.FARM_DEPLOYMENT_MISMATCH_STATUS = FARM_DEPLOYMENT_MISMATCH_STATUS; exports.getFarmPresetRuntime = getFarmPresetRuntime; exports.FarmDeploymentMismatchError = FarmDeploymentMismatchError; exports.normalizeFarmDeploymentId = normalizeFarmDeploymentId; exports.createFarmDeploymentRequestHeaders = createFarmDeploymentRequestHeaders; exports.getFarmRequestDeploymentId = getFarmRequestDeploymentId; exports.getFarmDeploymentMismatch = getFarmDeploymentMismatch; exports.createFarmDeploymentMismatchResponse = createFarmDeploymentMismatchResponse; exports.withFarmDeploymentResponse = withFarmDeploymentResponse; exports.getFarmResponseDeploymentId = getFarmResponseDeploymentId; exports.isFarmDeploymentMismatchResponse = isFarmDeploymentMismatchResponse; exports.createFarmDeploymentMismatchError = createFarmDeploymentMismatchError; exports.createFarmDeploymentCookie = createFarmDeploymentCookie;