@farm.js/core 0.1.0-beta.0

package/dist/chunk-6XDUHOEM.mjs

@@ -0,0 +1,157 @@
+import {
+  createRouteDataCacheKey
+} from "./chunk-4PTK6KT4.mjs";
+import {
+  subscribeFarmCacheInvalidation
+} from "./chunk-TXCFGOHW.mjs";
+import {
+  __name
+} from "./chunk-CGILA3WO.mjs";
+
+// src/client-cache.ts
+var _FarmClientDataCache = class _FarmClientDataCache {
+  constructor() {
+    this.entries = /* @__PURE__ */ new Map();
+    this.aliases = /* @__PURE__ */ new Map();
+    this.invalidatedAt = /* @__PURE__ */ new Map();
+    this.listeners = /* @__PURE__ */ new Map();
+    this.inflight = /* @__PURE__ */ new Map();
+    subscribeFarmCacheInvalidation((key) => this.invalidate(key));
+  }
+  get size() {
+    return this.entries.size;
+  }
+  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) {
+      this.entries.delete(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.emit(resolved);
+    return this;
+  }
+  delete(key) {
+    const resolved = this.resolveKey(key);
+    const deleted = this.entries.delete(resolved);
+    this.inflight.delete(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.invalidatedAt.clear();
+    this.inflight.clear();
+    for (const key of keys) this.emit(key);
+  }
+  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()) {
+    const resolved = this.resolveKey(key);
+    this.invalidatedAt.set(resolved, now);
+    const entry = this.entries.get(resolved);
+    if (entry) {
+      this.entries.set(resolved, {
+        ...entry,
+        staleAt: 0,
+        invalidatedAt: now
+      });
+    }
+    this.emit(resolved);
+  }
+  alias(alias, key) {
+    const resolved = this.resolveKey(key);
+    if (alias === resolved) return;
+    const aliasEntry = this.entries.get(alias);
+    if (aliasEntry && !this.entries.has(resolved)) {
+      this.entries.set(resolved, aliasEntry);
+    }
+    this.entries.delete(alias);
+    const aliasInflight = this.inflight.get(alias);
+    if (aliasInflight && !this.inflight.has(resolved)) {
+      this.inflight.set(resolved, aliasInflight);
+    }
+    this.inflight.delete(alias);
+    this.aliases.set(alias, resolved);
+    this.emit(alias);
+    this.emit(resolved);
+  }
+  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.delete(key);
+    };
+  }
+  getInflight(key) {
+    return this.inflight.get(this.resolveKey(key));
+  }
+  setInflight(key, promise) {
+    this.inflight.set(this.resolveKey(key), promise);
+  }
+  deleteInflight(key) {
+    this.inflight.delete(this.resolveKey(key));
+  }
+  emit(key) {
+    this.notifyListeners(key);
+    for (const [alias, target] of this.aliases) {
+      if (this.resolveKey(target) === key) {
+        this.notifyListeners(alias);
+      }
+    }
+  }
+  notifyListeners(key) {
+    for (const listener of this.listeners.get(key) ?? []) {
+      listener();
+    }
+  }
+};
+__name(_FarmClientDataCache, "FarmClientDataCache");
+var FarmClientDataCache = _FarmClientDataCache;
+var FARM_CLIENT_DATA_CACHE = /* @__PURE__ */ Symbol.for("farm.clientDataCache");
+var clientCacheGlobal = globalThis;
+var sharedFarmClientDataCache = clientCacheGlobal[FARM_CLIENT_DATA_CACHE] ?? (clientCacheGlobal[FARM_CLIENT_DATA_CACHE] = new FarmClientDataCache());
+function getFarmClientDataCache() {
+  return sharedFarmClientDataCache;
+}
+__name(getFarmClientDataCache, "getFarmClientDataCache");
+function normalizeFarmClientCacheKey(key) {
+  return typeof key === "string" ? key : createRouteDataCacheKey(key);
+}
+__name(normalizeFarmClientCacheKey, "normalizeFarmClientCacheKey");
+
+export {
+  getFarmClientDataCache,
+  normalizeFarmClientCacheKey
+};
+//# sourceMappingURL=chunk-6XDUHOEM.mjs.map

package/dist/chunk-6XDUHOEM.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/client-cache.ts"],"sourcesContent":["import { createRouteDataCacheKey, type RouteDataCacheKey } from \"./cache\";\nimport { subscribeFarmCacheInvalidation } from \"./cache-invalidation\";\n\nexport type FarmClientCacheKey = RouteDataCacheKey;\n\nexport type FarmClientCacheStatus = \"idle\" | \"pending\" | \"success\" | \"error\";\n\nexport type FarmClientCacheEntry<TData = unknown> = {\n  data: TData;\n  updatedAt: number;\n  staleAt: number;\n  gcAt?: number;\n  invalidatedAt?: number;\n  status?: FarmClientCacheStatus;\n  error?: Error | null;\n  fetching?: boolean;\n};\n\ntype FarmClientCacheListener = () => void;\n\nexport class FarmClientDataCache {\n  private entries = new Map<string, FarmClientCacheEntry>();\n  private aliases = new Map<string, string>();\n  private invalidatedAt = new Map<string, number>();\n  private listeners = new Map<string, Set<FarmClientCacheListener>>();\n  private inflight = new Map<string, Promise<unknown>>();\n\n  constructor() {\n    subscribeFarmCacheInvalidation((key) => this.invalidate(key));\n  }\n\n  get size(): number {\n    return this.entries.size;\n  }\n\n  resolveKey(key: string): string {\n    let resolved = key;\n    const seen = new Set<string>();\n\n    while (this.aliases.has(resolved) && !seen.has(resolved)) {\n      seen.add(resolved);\n      resolved = this.aliases.get(resolved)!;\n    }\n\n    return resolved;\n  }\n\n  get<TData = unknown>(key: string, now = Date.now()): FarmClientCacheEntry<TData> | undefined {\n    const resolved = this.resolveKey(key);\n    const entry = this.entries.get(resolved) as FarmClientCacheEntry<TData> | undefined;\n    if (!entry) return undefined;\n\n    if (entry.gcAt !== undefined && now >= entry.gcAt) {\n      this.entries.delete(resolved);\n      this.emit(resolved);\n      return undefined;\n    }\n\n    return entry;\n  }\n\n  set<TData>(key: string, entry: FarmClientCacheEntry<TData>): this {\n    const resolved = this.resolveKey(key);\n    const invalidatedAt = this.invalidatedAt.get(resolved);\n    const nextEntry =\n      invalidatedAt !== undefined && invalidatedAt > entry.updatedAt\n        ? { ...entry, staleAt: 0, invalidatedAt }\n        : { ...entry, invalidatedAt: undefined };\n\n    if (invalidatedAt === undefined || entry.updatedAt >= invalidatedAt) {\n      this.invalidatedAt.delete(resolved);\n    }\n\n    this.entries.set(resolved, nextEntry);\n    this.emit(resolved);\n    return this;\n  }\n\n  delete(key: string): boolean {\n    const resolved = this.resolveKey(key);\n    const deleted = this.entries.delete(resolved);\n    this.inflight.delete(resolved);\n    this.emit(resolved);\n    return deleted;\n  }\n\n  clear(): void {\n    const keys = new Set([...this.entries.keys(), ...this.listeners.keys()]);\n    this.entries.clear();\n    this.aliases.clear();\n    this.invalidatedAt.clear();\n    this.inflight.clear();\n    for (const key of keys) this.emit(key);\n  }\n\n  isStale(key: string, now = Date.now()): boolean {\n    const entry = this.get(key, now);\n    return !entry || entry.invalidatedAt !== undefined || now >= entry.staleAt;\n  }\n\n  invalidate(key: string, now = Date.now()): void {\n    const resolved = this.resolveKey(key);\n    this.invalidatedAt.set(resolved, now);\n\n    const entry = this.entries.get(resolved);\n    if (entry) {\n      this.entries.set(resolved, {\n        ...entry,\n        staleAt: 0,\n        invalidatedAt: now,\n      });\n    }\n\n    this.emit(resolved);\n  }\n\n  alias(alias: string, key: string): void {\n    const resolved = this.resolveKey(key);\n    if (alias === resolved) return;\n\n    const aliasEntry = this.entries.get(alias);\n    if (aliasEntry && !this.entries.has(resolved)) {\n      this.entries.set(resolved, aliasEntry);\n    }\n\n    this.entries.delete(alias);\n    const aliasInflight = this.inflight.get(alias);\n    if (aliasInflight && !this.inflight.has(resolved)) {\n      this.inflight.set(resolved, aliasInflight);\n    }\n    this.inflight.delete(alias);\n    this.aliases.set(alias, resolved);\n    this.emit(alias);\n    this.emit(resolved);\n  }\n\n  subscribe(key: string, listener: FarmClientCacheListener): () => void {\n    let listeners = this.listeners.get(key);\n    if (!listeners) {\n      listeners = new Set();\n      this.listeners.set(key, listeners);\n    }\n\n    listeners.add(listener);\n    return () => {\n      listeners!.delete(listener);\n      if (listeners!.size === 0) this.listeners.delete(key);\n    };\n  }\n\n  getInflight<TData>(key: string): Promise<TData> | undefined {\n    return this.inflight.get(this.resolveKey(key)) as Promise<TData> | undefined;\n  }\n\n  setInflight<TData>(key: string, promise: Promise<TData>): void {\n    this.inflight.set(this.resolveKey(key), promise);\n  }\n\n  deleteInflight(key: string): void {\n    this.inflight.delete(this.resolveKey(key));\n  }\n\n  private emit(key: string): void {\n    this.notifyListeners(key);\n    for (const [alias, target] of this.aliases) {\n      if (this.resolveKey(target) === key) {\n        this.notifyListeners(alias);\n      }\n    }\n  }\n\n  private notifyListeners(key: string): void {\n    for (const listener of this.listeners.get(key) ?? []) {\n      listener();\n    }\n  }\n}\n\nconst FARM_CLIENT_DATA_CACHE = Symbol.for(\"farm.clientDataCache\");\nconst clientCacheGlobal = globalThis as typeof globalThis & {\n  [FARM_CLIENT_DATA_CACHE]?: FarmClientDataCache;\n};\nconst sharedFarmClientDataCache = (clientCacheGlobal[FARM_CLIENT_DATA_CACHE] ??=\n  new FarmClientDataCache());\n\nexport function getFarmClientDataCache(): FarmClientDataCache {\n  return sharedFarmClientDataCache;\n}\n\nexport function normalizeFarmClientCacheKey(key: FarmClientCacheKey): string {\n  return typeof key === \"string\" ? key : createRouteDataCacheKey(key);\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-74YTBPTY.mjs

@@ -0,0 +1,450 @@
+import {
+  __name
+} from "./chunk-CGILA3WO.mjs";
+
+// src/layers.ts
+import { existsSync, readFileSync, realpathSync, statSync } from "fs";
+import { mkdir, unlink } from "fs/promises";
+import { createRequire } 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");
+async function loadFarmConfigFile(configPath, options) {
+  const { build, transform } = await import("esbuild");
+  const cacheRoot = path.resolve(options.cacheRoot || options.root);
+  const configCacheDir = path.join(cacheRoot, ".farm", ".config-loader");
+  const configEntryChecks = /* @__PURE__ */ new Map();
+  await mkdir(configCacheDir, { recursive: true });
+  const modulePath = path.join(
+    configCacheDir,
+    `farm-config-${Date.now()}-${Math.random().toString(36).slice(2)}.mjs`
+  );
+  await build({
+    absWorkingDir: path.resolve(options.root),
+    entryPoints: [path.resolve(configPath)],
+    outfile: modulePath,
+    bundle: true,
+    format: "esm",
+    platform: "node",
+    target: `node${process.versions.node.split(".")[0]}`,
+    plugins: [
+      {
+        name: "farm-config-package-resolution",
+        setup(pluginBuild) {
+          pluginBuild.onResolve({ filter: /^@farm.js\/core$/ }, async (args) => {
+            if (args.pluginData?.farmConfigExternal || args.kind !== "import-statement" || !args.importer) {
+              return;
+            }
+            let configEntryCheck = configEntryChecks.get(args.importer);
+            if (!configEntryCheck) {
+              configEntryCheck = onlyImportsFarmConfigHelpers(args.importer, transform);
+              configEntryChecks.set(args.importer, configEntryCheck);
+            }
+            if (!await configEntryCheck) return;
+            const resolved = await pluginBuild.resolve(FARM_CONFIG_ENTRY, {
+              importer: args.importer,
+              kind: args.kind,
+              namespace: args.namespace,
+              resolveDir: args.resolveDir,
+              pluginData: { farmConfigExternal: true }
+            });
+            if (resolved.errors.length > 0 || !resolved.path) return;
+            return {
+              path: resolved.path,
+              external: true,
+              warnings: resolved.warnings
+            };
+          });
+          pluginBuild.onResolve({ filter: /^[^./]/ }, async (args) => {
+            if (args.pluginData?.farmConfigExternal) return;
+            const resolved = await pluginBuild.resolve(args.path, {
+              importer: args.importer,
+              kind: args.kind,
+              namespace: args.namespace,
+              resolveDir: args.resolveDir,
+              pluginData: { farmConfigExternal: true }
+            });
+            if (resolved.errors.length > 0 || !resolved.path) {
+              return { path: args.path, external: true };
+            }
+            return {
+              path: resolved.path,
+              external: true,
+              warnings: resolved.warnings
+            };
+          });
+        }
+      }
+    ],
+    jsx: "automatic",
+    logLevel: "silent",
+    sourcemap: "inline"
+  });
+  const moduleUrl = `${pathToFileURL(modulePath).href}?t=${Date.now()}`;
+  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 {
+    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(source, {
+      format: "esm",
+      jsx: "automatic",
+      loader: getEsbuildLoader(importer),
+      sourcefile: importer
+    });
+    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 getEsbuildLoader(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(getEsbuildLoader, "getEsbuildLoader");
+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,
+  loadFarmConfigFile
+};
+//# sourceMappingURL=chunk-74YTBPTY.mjs.map