@farm.js/core 0.1.61 → 0.1.62

package/dist/chunk-5PZJ63PK.mjs

@@ -0,0 +1,17 @@
+import {
+  setAPIRequestRuntimeResolver
+} from "./chunk-5Y4GYKKH.mjs";
+
+// src/api/server-context.ts
+import { AsyncLocalStorage } from "async_hooks";
+var API_RUNTIME_STORAGE = /* @__PURE__ */ Symbol.for("@farm.js/core/api-request-storage");
+var runtimeGlobal = globalThis;
+var storage = runtimeGlobal[API_RUNTIME_STORAGE] ?? (runtimeGlobal[API_RUNTIME_STORAGE] = new AsyncLocalStorage());
+setAPIRequestRuntimeResolver(() => storage.getStore());
+function _runWithAPIRequestRuntime(runtime, run) {
+  return storage.run(runtime, run);
+}
+
+export {
+  _runWithAPIRequestRuntime
+};

package/dist/chunk-5Y22WNTO.mjs

@@ -0,0 +1,237 @@
+import {
+  readFarmNativeWebSpec
+} from "./chunk-43V3ANPQ.mjs";
+import {
+  isPlainObject,
+  readAppPackageJson
+} from "./chunk-UB7RVEMX.mjs";
+
+// src/mobile/modules.ts
+import { existsSync, readdirSync, readFileSync, realpathSync } from "fs";
+import * as path from "path";
+var MODULE_KEYS = /* @__PURE__ */ new Set(["permissions", "usage", "web"]);
+var PERMISSION = /^[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)+$/;
+var BARE_PERMISSION = /^[A-Z][A-Z0-9_]*$/;
+var USAGE_KEY = /^NS[A-Za-z0-9]+UsageDescription$/;
+var SPEC_FILE = /^Native[A-Za-z0-9_]+\.(?:ts|js)$/;
+var SPEC_NAME = /TurboModuleRegistry\s*\.\s*(?:getEnforcing|get)\s*(?:<[^>]*>)?\s*\(\s*(["'`])([A-Za-z_$][\w$]*)\1/;
+function relative2(root, file) {
+  return path.relative(root, file).split(path.sep).join("/");
+}
+function scanFarmMobileAppModules(options) {
+  const dir = path.resolve(options.root, options.srcDir ?? "src", "native");
+  if (!existsSync(dir)) return void 0;
+  const entries = readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => entry.name).sort();
+  const specs = [];
+  const names = /* @__PURE__ */ new Map();
+  for (const name of entries.filter((entry) => SPEC_FILE.test(entry))) {
+    const file = path.join(dir, name);
+    const match = SPEC_NAME.exec(readFileSync(file, "utf8"));
+    const shown = relative2(options.root, file);
+    if (!match) {
+      throw new TypeError(
+        `${shown} is a native module spec (Native*.ts) without a registered name. Export TurboModuleRegistry.getEnforcing<Spec>("${name.replace(/^Native|\.\w+$/g, "")}") as its default, as in a React Native app.`
+      );
+    }
+    const other = names.get(match[2]);
+    if (other) {
+      throw new TypeError(
+        `${shown} and ${other} both register the native module "${match[2]}". Give each spec its own name.`
+      );
+    }
+    names.set(match[2], shown);
+    specs.push({ name: match[2], file });
+  }
+  const android = entries.filter((entry) => entry.endsWith(".kt")).map((entry) => path.join(dir, entry));
+  const ios = entries.filter((entry) => /\.(?:mm|m|h|swift)$/.test(entry)).map((entry) => path.join(dir, entry));
+  if (specs.length === 0 && android.length === 0 && ios.length === 0) return void 0;
+  return { dir, specs, android, ios };
+}
+function findPackage(name, from) {
+  let dir = from;
+  for (; ; ) {
+    const candidate = path.join(dir, "node_modules", name);
+    if (existsSync(path.join(candidate, "package.json"))) return realpathSync(candidate);
+    const parent = path.dirname(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+function installedModuleProblem(name, root, dependencies) {
+  if (!(name in dependencies)) return "unknown";
+  const dir = findPackage(name, root);
+  if (!dir) return "missing";
+  try {
+    const pkg = JSON.parse(readFileSync(path.join(dir, "package.json"), "utf8"));
+    return isPlainObject(pkg) && isPlainObject(pkg.codegenConfig) ? void 0 : "not-a-module";
+  } catch {
+    return "not-a-module";
+  }
+}
+function resolveFarmMobileModules(input, options, fail) {
+  if (input === void 0) return {};
+  if (!isPlainObject(input)) {
+    fail(
+      'modules must be an object keyed by module name, such as { Device: { permissions: ["android.permission.VIBRATE"] } }.'
+    );
+  }
+  const issues = [];
+  const resolved = {};
+  const appModules = new Set(options.appModules ?? []);
+  const usageOwners = /* @__PURE__ */ new Map();
+  let dependencies;
+  const specDir = relative2(
+    options.root,
+    path.resolve(options.root, options.srcDir ?? "src", "native")
+  );
+  for (const name of Object.keys(input).sort()) {
+    const where = `modules[${JSON.stringify(name)}]`;
+    const entry = input[name];
+    if (!appModules.has(name)) {
+      dependencies ?? (dependencies = ((value) => isPlainObject(value) ? value : {})(
+        readAppPackageJson(options.root).dependencies
+      ));
+      const problem = installedModuleProblem(name, options.root, dependencies);
+      if (problem === "unknown") {
+        issues.push(
+          `${where} is not one of the app's native modules or an installed React Native module. Use the name a ${specDir}/Native*.ts spec registers, or a package in dependencies in package.json.`
+        );
+      } else if (problem === "missing") {
+        issues.push(
+          `${where} is in dependencies but not installed. Install the app's dependencies, then run the command again.`
+        );
+      } else if (problem === "not-a-module") {
+        issues.push(
+          `${where} names a package with no "codegenConfig" in its package.json, so it is not a React Native module for the new architecture. Remove the entry, or upgrade the package.`
+        );
+      }
+    }
+    if (!isPlainObject(entry)) {
+      issues.push(
+        `${where} must be an object, such as { permissions: ["android.permission.VIBRATE"] }.`
+      );
+      continue;
+    }
+    for (const key of Object.keys(entry)) {
+      if (!MODULE_KEYS.has(key)) {
+        issues.push(`unknown option ${where}.${key}. Supported: permissions, usage, web.`);
+      }
+    }
+    const permissions = [];
+    if (entry.permissions !== void 0) {
+      if (!Array.isArray(entry.permissions)) {
+        issues.push(
+          `${where}.permissions must be an array of Android permissions, such as ["android.permission.VIBRATE"].`
+        );
+      } else {
+        entry.permissions.forEach((permission, index) => {
+          const at = `${where}.permissions[${index}]`;
+          if (typeof permission !== "string" || !PERMISSION.test(permission)) {
+            const hint = typeof permission === "string" && BARE_PERMISSION.test(permission) ? ` Use "android.permission.${permission}".` : "";
+            issues.push(
+              `${at} must be a full Android permission name such as "android.permission.VIBRATE", got ${JSON.stringify(permission)}.${hint}`
+            );
+          } else if (!permissions.includes(permission)) {
+            permissions.push(permission);
+          }
+        });
+      }
+    }
+    const usage = {};
+    if (entry.usage !== void 0) {
+      if (!isPlainObject(entry.usage)) {
+        issues.push(
+          `${where}.usage must be an object of iOS usage strings, such as { NSCameraUsageDescription: "Scans receipts." }.`
+        );
+      } else {
+        for (const [key, value] of Object.entries(entry.usage)) {
+          const at = `${where}.usage.${key}`;
+          if (!USAGE_KEY.test(key)) {
+            issues.push(
+              `${at} is not an iOS usage-description key. Keys are NS...UsageDescription, such as NSCameraUsageDescription.`
+            );
+          } else if (typeof value !== "string" || !value.trim()) {
+            issues.push(
+              `${at} must be a non-empty string: the sentence iOS shows when it asks for access.`
+            );
+          } else {
+            const owner = usageOwners.get(key);
+            if (owner && owner.value !== value.trim()) {
+              issues.push(
+                `${at} and modules[${JSON.stringify(owner.name)}].usage.${key} set different strings, and Info.plist has one per key. Set it on one module.`
+              );
+            }
+            usageOwners.set(key, { name, value: value.trim() });
+            usage[key] = value.trim();
+          }
+        }
+      }
+    }
+    let web = false;
+    if (entry.web !== void 0) {
+      if (typeof entry.web !== "boolean") {
+        issues.push(`${where}.web must be true or false.`);
+      } else if (entry.web && !appModules.has(name)) {
+        issues.push(
+          `${where}.web is true, but web screens reach only the app's own modules in ${specDir}. "${name}" needs the React Native JS runtime, which web screens do not have. Remove web, and call the module from a native screen (page.native.tsx).`
+        );
+      } else {
+        web = entry.web;
+      }
+    }
+    resolved[name] = { permissions, usage, web };
+  }
+  if (issues.length === 1) fail(issues[0]);
+  if (issues.length > 1) {
+    fail(
+      `modules has ${issues.length} problems:
+${issues.map((issue) => `  - ${issue}`).join("\n")}`
+    );
+  }
+  return resolved;
+}
+function readFarmMobileWebModules(appModules, modules, options) {
+  const issues = [];
+  const specs = appModules.specs.map((spec) => {
+    if (!modules[spec.name]?.web) return spec;
+    const shown = relative2(options.root, spec.file);
+    const where = `modules[${JSON.stringify(spec.name)}].web`;
+    let web;
+    try {
+      web = readFarmNativeWebSpec({ root: options.root, file: spec.file });
+    } catch (error) {
+      issues.push(`${where}: ${error.message}`);
+      return spec;
+    }
+    for (const { method, reason } of web.unsupported) {
+      issues.push(
+        `${where}: ${shown} declares ${method}(), but ${reason}. Change the parameter to a string, number, boolean, object, or array, or remove web and call the module from a native screen (page.native.tsx).`
+      );
+    }
+    if (web.methods.some((method) => method.name === "available")) {
+      issues.push(
+        `${where}: ${shown} declares available(), which web screens use to check for the module (native.<module>.available()). Rename the method.`
+      );
+    }
+    if (web.methods.length === 0 && web.unsupported.length === 0) {
+      issues.push(
+        `${where}: ${shown} declares no method that returns a Promise, and web screens call only those. Remove web, or declare one, such as model(): Promise<string>.`
+      );
+    }
+    return { ...spec, web };
+  });
+  if (issues.length === 1) throw new TypeError(issues[0]);
+  if (issues.length > 1) {
+    throw new TypeError(
+      `modules has ${issues.length} problems:
+${issues.map((issue) => `  - ${issue}`).join("\n")}`
+    );
+  }
+  return { ...appModules, specs };
+}
+
+export {
+  scanFarmMobileAppModules,
+  resolveFarmMobileModules,
+  readFarmMobileWebModules
+};

package/dist/chunk-5Y2P454O.cjs

@@ -0,0 +1,421 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 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(); } } 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 _chunkDQJ2CIH7cjs = require('./chunk-DQJ2CIH7.cjs');
+
+// src/layers.ts
+var _fs = require('fs');
+var _promises = require('fs/promises');
+var _module = require('module');
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var _url = require('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 = _path2.default.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 = 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
+    });
+  };
+  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
+  };
+}
+function getFarmSourceRoots(config) {
+  const roots = (_nullishCoalesce(config.layers, () => ( []))).map((layer) => ({
+    name: layer.name,
+    root: layer.root,
+    srcDir: layer.srcDir,
+    layer: true
+  }));
+  roots.push({
+    name: "project",
+    root: _path2.default.resolve(config.root || process.cwd()),
+    srcDir: config.srcDir || "src",
+    layer: false
+  });
+  return roots;
+}
+function getFarmAppDirectories(config) {
+  return getFarmSourceRoots(config).map((source) => _path2.default.join(source.root, source.srcDir, "app"));
+}
+function getFarmLayerAliases(layers) {
+  return Object.fromEntries(
+    (_nullishCoalesce(layers, () => ( []))).map((layer) => [`#layers/${layer.name}`, _path2.default.join(layer.root, layer.srcDir)])
+  );
+}
+var WINDOWS_ABSOLUTE_PATH_RE = /^(?:[A-Za-z]:[\\/]|\\\\)/;
+function toExternalSpecifier(resolvedPath) {
+  return _path2.default.isAbsolute(resolvedPath) ? _url.pathToFileURL.call(void 0, resolvedPath).href : resolvedPath;
+}
+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") || _module.isBuiltin.call(void 0, source) || _path2.default.isAbsolute(source) || WINDOWS_ABSOLUTE_PATH_RE.test(source)) {
+        return null;
+      }
+      const resolveRuntimePath = async (specifier) => {
+        const resolved = await this.resolve(specifier, importer, {
+          kind: extraOptions.kind,
+          skipSelf: true
+        });
+        if (!_optionalChain([resolved, 'optionalAccess', _ => _.id]) || !_chunkDQJ2CIH7cjs.isDeclarationFile.call(void 0, resolved.id)) return _optionalChain([resolved, 'optionalAccess', _2 => _2.id]);
+        return await _asyncNullishCoalesce(await _chunkDQJ2CIH7cjs.resolvePackageWithoutTsconfig.call(void 0, specifier, importer, extraOptions.kind), async () => ( void 0));
+      };
+      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 };
+    }
+  };
+}
+var FARM_CONFIG_ROOT = /* @__PURE__ */ Symbol.for("farm.configRoot");
+async function loadFarmConfigFile(configPath, options) {
+  const { transform } = await import("rolldown/utils");
+  const cacheRoot = _path2.default.resolve(options.cacheRoot || options.root);
+  const configCacheDir = _path2.default.join(cacheRoot, ".farm", ".config-loader");
+  await _promises.mkdir.call(void 0, configCacheDir, { recursive: true });
+  const modulePath = _path2.default.join(
+    configCacheDir,
+    `farm-config-${Date.now()}-${Math.random().toString(36).slice(2)}.mjs`
+  );
+  await _chunkDQJ2CIH7cjs.bundleNodeModule.call(void 0, {
+    root: _path2.default.resolve(options.root),
+    entry: _path2.default.resolve(configPath),
+    outfile: modulePath,
+    target: `node${process.versions.node.split(".")[0]}`,
+    plugins: [createFarmConfigResolutionPlugin({ transform })]
+  });
+  const moduleUrl = `${_url.pathToFileURL.call(void 0, 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 _promises.unlink.call(void 0, modulePath).catch(() => void 0);
+  }
+}
+async function onlyImportsFarmConfigHelpers(importer, transform) {
+  try {
+    const source = _fs.readFileSync.call(void 0, 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 = _nullishCoalesce(match.index, () => ( 0));
+      safeImportRanges.push({ start, end: start + match[0].length });
+    }
+    return references.every((reference) => {
+      const index = _nullishCoalesce(reference.index, () => ( -1));
+      return safeImportRanges.some((range) => index >= range.start && index < range.end);
+    });
+  } catch (e) {
+    return false;
+  }
+}
+function getSourceLang(file) {
+  switch (_path2.default.extname(file)) {
+    case ".ts":
+    case ".mts":
+    case ".cts":
+      return "ts";
+    case ".tsx":
+      return "tsx";
+    case ".jsx":
+      return "jsx";
+    default:
+      return "js";
+  }
+}
+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();
+  });
+}
+function resolveLayerSource(source, ownerRoot) {
+  if (isPathLayerSource(source)) {
+    const target = source.startsWith("file:") ? _path2.default.resolve(ownerRoot, source.slice("file:".length)) : _path2.default.resolve(ownerRoot, source);
+    if (!_fs.existsSync.call(void 0, target)) {
+      throw new Error(`Cannot resolve Farm layer ${JSON.stringify(source)} from ${ownerRoot}`);
+    }
+    const stats = _fs.statSync.call(void 0, target);
+    const root = stats.isDirectory() ? target : _path2.default.dirname(target);
+    return {
+      root: normalizeRealPath(root),
+      configFile: stats.isFile() ? normalizeRealPath(target) : void 0
+    };
+  }
+  const requireFromOwner = _module.createRequire.call(void 0, _path2.default.join(ownerRoot, "package.json"));
+  let packageJsonPath;
+  try {
+    packageJsonPath = requireFromOwner.resolve(`${source}/package.json`);
+  } catch (e2) {
+  }
+  if (packageJsonPath) {
+    return { root: normalizeRealPath(_path2.default.dirname(packageJsonPath)) };
+  }
+  try {
+    const entryPath = requireFromOwner.resolve(source);
+    const packageRoot = findNearestPackageRoot(entryPath);
+    if (packageRoot) return { root: normalizeRealPath(packageRoot) };
+  } catch (e3) {
+  }
+  throw new Error(`Cannot resolve Farm layer package ${JSON.stringify(source)} from ${ownerRoot}`);
+}
+function findNearestPackageRoot(entryPath) {
+  let current = _fs.statSync.call(void 0, entryPath).isDirectory() ? entryPath : _path2.default.dirname(entryPath);
+  while (true) {
+    if (_fs.existsSync.call(void 0, _path2.default.join(current, "package.json"))) return current;
+    const parent = _path2.default.dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+function findFarmConfigFile(root, explicitPath) {
+  if (explicitPath) return explicitPath;
+  for (const fileName of CONFIG_FILENAMES) {
+    const candidate = _path2.default.join(root, fileName);
+    if (_fs.existsSync.call(void 0, candidate)) return candidate;
+  }
+  return void 0;
+}
+function getLayerName(source, root) {
+  if (!isPathLayerSource(source)) {
+    const packageName = source.split("/").filter(Boolean).pop();
+    if (packageName) return sanitizeLayerName(packageName);
+  }
+  try {
+    const packageJson = JSON.parse(_fs.readFileSync.call(void 0, _path2.default.join(root, "package.json"), "utf8"));
+    if (typeof packageJson.name === "string") {
+      return sanitizeLayerName(packageJson.name.split("/").pop() || packageJson.name);
+    }
+  } catch (e4) {
+  }
+  return sanitizeLayerName(_path2.default.basename(root));
+}
+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;
+}
+function normalizeLayerSrcDir(value) {
+  if (value === void 0) return "src";
+  if (typeof value !== "string" || value.trim() === "" || _path2.default.isAbsolute(value)) {
+    throw new TypeError("A Farm layer srcDir must be a non-empty relative path");
+  }
+  const normalized = _path2.default.normalize(value.trim());
+  if (normalized === ".." || normalized.startsWith(`..${_path2.default.sep}`)) {
+    throw new TypeError("A Farm layer srcDir cannot leave the layer root");
+  }
+  return normalized;
+}
+function getLayerDefaults(config) {
+  return Object.fromEntries(
+    Object.entries(config).filter(
+      ([key, value]) => key !== "extends" && value !== void 0 && !LAYER_LOCAL_CONFIG_KEYS.has(key)
+    )
+  );
+}
+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;
+}
+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;
+}
+function mergeConfigListResolvers(base, override) {
+  return async () => [...await resolveConfigList(base), ...await resolveConfigList(override)];
+}
+async function resolveConfigList(value) {
+  const resolved = typeof value === "function" ? await value() : value;
+  return toArray(resolved);
+}
+function toArray(value) {
+  if (value === void 0 || value === null) return [];
+  return Array.isArray(value) ? value : [value];
+}
+function isPlainObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function isPathLayerSource(source) {
+  return source.startsWith(".") || source.startsWith("/") || source.startsWith("file:") || /^[a-zA-Z]:[\\/]/.test(source);
+}
+function normalizeRealPath(value) {
+  return _path2.default.resolve(_fs.realpathSync.call(void 0, value));
+}
+
+
+
+
+
+
+
+
+exports.resolveFarmLayers = resolveFarmLayers; exports.getFarmSourceRoots = getFarmSourceRoots; exports.getFarmAppDirectories = getFarmAppDirectories; exports.getFarmLayerAliases = getFarmLayerAliases; exports.createFarmConfigResolutionPlugin = createFarmConfigResolutionPlugin; exports.loadFarmConfigFile = loadFarmConfigFile;

package/dist/chunk-5Y4GYKKH.mjs

@@ -0,0 +1,13 @@
+// src/api/server-client-bridge.ts
+var API_RUNTIME_RESOLVER = /* @__PURE__ */ Symbol.for("farm.apiRequestRuntimeResolver");
+function setAPIRequestRuntimeResolver(resolver) {
+  globalThis[API_RUNTIME_RESOLVER] = resolver;
+}
+function resolveAPIRequestRuntime() {
+  return globalThis[API_RUNTIME_RESOLVER]?.();
+}
+
+export {
+  setAPIRequestRuntimeResolver,
+  resolveAPIRequestRuntime
+};