@farm.js/core 0.1.61 → 0.1.62

package/dist/runtime-M6UJCSLA.mjs

@@ -0,0 +1,1336 @@
+import {
+  readFarmMobileWebModules,
+  resolveFarmMobileModules,
+  scanFarmMobileAppModules
+} from "./chunk-5Y22WNTO.mjs";
+import "./chunk-43V3ANPQ.mjs";
+import {
+  FARM_SHELL_HEADER,
+  FARM_SHELL_PARAM_SEGMENT,
+  FARM_SHELL_RENDER_HEADER,
+  FARM_SHELL_ROUTE_HEADER,
+  createFarmMobileShellRenderPath
+} from "./chunk-UYRI6U3P.mjs";
+import {
+  readFarmMobileClientManifest
+} from "./chunk-ZNXTU4YH.mjs";
+import "./chunk-E4RDMG3K.mjs";
+import {
+  loadConfig,
+  resolveConfig
+} from "./chunk-VWW4Q3BJ.mjs";
+import "./chunk-VISQDC6W.mjs";
+import {
+  createPlatformBlockChecker,
+  isPlainObject,
+  readAppPackageJson,
+  resolveAppPackageName,
+  resolvePlatformBlock,
+  resolvePlatformProfile
+} from "./chunk-UB7RVEMX.mjs";
+import {
+  scanRoutePatterns
+} from "./chunk-SA7MLSP4.mjs";
+import "./chunk-Q5B4LNON.mjs";
+import {
+  resolveFarmServerComponentsMode
+} from "./chunk-PAKCHVUS.mjs";
+import "./chunk-X3XUZWRB.mjs";
+import "./chunk-XR2ZIBQK.mjs";
+import "./chunk-CU5SYTJG.mjs";
+import {
+  getFarmRendererComponentExtensions
+} from "./chunk-ES2LD2YD.mjs";
+import "./chunk-T4TBK5NY.mjs";
+import "./chunk-22W4FNTG.mjs";
+import "./chunk-2WZTGPK6.mjs";
+import "./chunk-KVW2M6PI.mjs";
+import {
+  getFarmSourceRoots
+} from "./chunk-52Y3C3HG.mjs";
+import "./chunk-2NGZFOKG.mjs";
+import "./chunk-N33DLJBC.mjs";
+import "./chunk-UIJOLBUL.mjs";
+import "./chunk-YSXTNSXS.mjs";
+import "./chunk-VFXE6NWR.mjs";
+import "./chunk-TZVUF5JJ.mjs";
+import "./chunk-DQF3QLOH.mjs";
+import "./chunk-WXFY5JIY.mjs";
+import "./chunk-E46NXBNJ.mjs";
+import "./chunk-YP7YO3S3.mjs";
+import "./chunk-YWPNIYUP.mjs";
+import "./chunk-TGULJSHD.mjs";
+import "./chunk-H4WUWLQR.mjs";
+import "./chunk-M53MIIXY.mjs";
+import "./chunk-46P5KNTE.mjs";
+import "./chunk-K3RU5MOR.mjs";
+import "./chunk-KPAJWD3N.mjs";
+import "./chunk-EDPENAVO.mjs";
+import "./chunk-FSXSQQTV.mjs";
+import "./chunk-C7GJDVN4.mjs";
+import "./chunk-6YFC3ZFX.mjs";
+import "./chunk-EVMXPJCB.mjs";
+import "./chunk-TGSEVBPO.mjs";
+import "./chunk-QSTRBKHZ.mjs";
+import "./chunk-MU5V7XHL.mjs";
+import "./chunk-JSDV2NUN.mjs";
+import "./chunk-H3ASZDT7.mjs";
+import "./chunk-2DA7CLY7.mjs";
+import "./chunk-CO6UYM2D.mjs";
+import "./chunk-2I6PUKWJ.mjs";
+import "./chunk-QDWMCFTH.mjs";
+import "./chunk-D2LCAV6L.mjs";
+import "./chunk-GYMGK467.mjs";
+import "./chunk-GUZC226X.mjs";
+import "./chunk-W6QLRQ3V.mjs";
+import "./chunk-AY2YD5ZX.mjs";
+import "./chunk-WCLLPR6H.mjs";
+import "./chunk-UAQD67HM.mjs";
+import "./chunk-AZQXXXDX.mjs";
+import "./chunk-ONG4RDW3.mjs";
+import "./chunk-LM55GS4R.mjs";
+import "./chunk-JNYFXL7X.mjs";
+import "./chunk-6HRAK7I5.mjs";
+import "./chunk-OHWM2VI4.mjs";
+import "./chunk-VIXTAVEA.mjs";
+import "./chunk-7S7AAK2D.mjs";
+import {
+  normalizeFarmBasePath
+} from "./chunk-SF3JB56B.mjs";
+import {
+  compareRoutePatternSpecificity,
+  getRoutePatternShape
+} from "./chunk-AYP2YFVN.mjs";
+import "./chunk-Y6FXYEAI.mjs";
+
+// src/mobile/runtime.ts
+import { mkdir, readFile, rm, writeFile } from "fs/promises";
+import * as path2 from "path";
+
+// src/mobile/config.ts
+var MOBILE_KEYS = /* @__PURE__ */ new Set([
+  "name",
+  "id",
+  "server",
+  "tabs",
+  "routes",
+  "native",
+  "shells",
+  "modules"
+]);
+var ROUTE_KEYS = /* @__PURE__ */ new Set(["presentation"]);
+var TAB_KEYS = /* @__PURE__ */ new Set(["path", "title", "icon"]);
+var NATIVE_KEYS = /* @__PURE__ */ new Set(["engine", "auto", "routes", "islands", "prefetch", "budgets"]);
+var NATIVE_ROUTE_KEYS = /* @__PURE__ */ new Set(["screen", "android", "ios", "presentation"]);
+var BUDGET_KEYS = /* @__PURE__ */ new Set(["appSizeMb", "screenOpenMs", "droppedFrames"]);
+var PAGE_KEYS = /* @__PURE__ */ new Set(["presentation", "prefetch", "native"]);
+var PRESENTATIONS = /* @__PURE__ */ new Set(["push", "modal", "replace"]);
+var SCREENS = /* @__PURE__ */ new Set(["web", "native", "platform"]);
+var ENGINES = /* @__PURE__ */ new Set(["react-native", "platform"]);
+var AUTO_MODES = /* @__PURE__ */ new Set(["off", "report", "on"]);
+var MOBILE_OS = /* @__PURE__ */ new Set(["android", "ios"]);
+var MAX_TABS = 5;
+var APP_ID_SEGMENT = /^[A-Za-z][A-Za-z0-9]*$/;
+var JAVA_KEYWORDS = new Set(
+  "abstract assert boolean break byte case catch char class const continue default do double else enum extends false final finally float for goto if implements import instanceof int interface long native new null package private protected public return short static strictfp super switch synchronized this throw throws transient true try void volatile while".split(" ")
+);
+var ICON_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+var ISLAND_NAME = /^[A-Z][A-Za-z0-9]*$/;
+function mobileChecker(context) {
+  return createPlatformBlockChecker(context ? `mobile (os: ${context.os})` : "mobile");
+}
+function isLoopbackOrLanHost(hostname) {
+  const host = hostname.replace(/^\[|\]$/g, "").toLowerCase();
+  if (host === "localhost" || host.endsWith(".localhost") || host.endsWith(".local")) return true;
+  if (host === "::1" || /^fe[89ab][0-9a-f]:/.test(host) || /^f[cd][0-9a-f]{2}:/.test(host)) {
+    return true;
+  }
+  const ipv4 = host.match(/^(\d+)\.(\d+)\.(\d+)\.(\d+)$/);
+  if (!ipv4) return false;
+  const [a, b] = [Number(ipv4[1]), Number(ipv4[2])];
+  return a === 127 || a === 10 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168 || a === 169 && b === 254;
+}
+function resolveFarmMobileServer(value, context, check = mobileChecker(), key = "server") {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    return check.fail(`${key} must be an absolute URL such as "https://notes.example.com".`);
+  }
+  if (url.username || url.password || url.search || url.hash || url.pathname !== "/") {
+    check.fail(
+      `${key} must be an origin such as "https://notes.example.com", without a path, query, or credentials. A base path comes from basePath.`
+    );
+  }
+  if (url.protocol === "https:") return url.origin;
+  if (url.protocol !== "http:") check.fail(`${key} must use https://, got "${url.protocol}".`);
+  if (context.command !== "dev") {
+    check.fail(
+      `${key} must use https:// in a build, got "${value}". http:// is allowed only for loopback and LAN hosts in dev.`
+    );
+  }
+  if (!isLoopbackOrLanHost(url.hostname)) {
+    check.fail(
+      `${key} may use http:// only for a loopback or LAN host (such as http://10.0.2.2:3000 for the Android emulator), got "${value}". Use https:// for public hosts.`
+    );
+  }
+  return url.origin;
+}
+function checkAppId(id, { fail }) {
+  const segments = id.split(".");
+  if (segments.length < 2 || !segments.every((segment) => APP_ID_SEGMENT.test(segment))) {
+    fail(
+      `id must be a reverse-DNS identifier such as "com.example.notes", with segments of letters and digits that start with a letter (valid on Android and iOS), got "${id}".`
+    );
+  }
+  const keyword = segments.find((segment) => JAVA_KEYWORDS.has(segment.toLowerCase()));
+  if (keyword) fail(`id segment "${keyword}" is a Java keyword, which Android rejects.`);
+}
+function nativeModuleMovedMessage(where, pattern) {
+  const dir = pattern === "/" ? "" : stripRouteGroupsFromPattern(pattern);
+  return `${where}.native no longer names a src/native/ module (src/native/ is for native module specs). Add src/app${dir}/page.native.tsx next to its page.tsx, or set native: { routes: { "${pattern}": { screen: "native" } } }.`;
+}
+function checkRouteKey(pattern, where, { fail }) {
+  if (!pattern.startsWith("/")) fail(`${where}: the key must be an app route such as "/notes".`);
+}
+function checkPresentation(value, where, { fail }) {
+  if (value !== void 0 && !PRESENTATIONS.has(value)) {
+    fail(`${where}.presentation must be "push", "modal", or "replace".`);
+  }
+}
+function checkPrefetch(value, where, { fail }) {
+  if (value !== void 0 && value !== "intent" && value !== "off") {
+    fail(`${where}prefetch must be "intent" or "off".`);
+  }
+}
+function validateNativeConfig(native, check) {
+  const { checkKeys } = check;
+  function fail(message) {
+    return check.fail(message);
+  }
+  if (!isPlainObject(native)) {
+    fail('native must be an object, such as { routes: { "/feed": { screen: "native" } } }.');
+  }
+  checkKeys(native, NATIVE_KEYS, "native.");
+  if (native.engine !== void 0 && !ENGINES.has(native.engine)) {
+    fail('native.engine must be "react-native" or "platform".');
+  }
+  if (native.auto !== void 0 && !AUTO_MODES.has(native.auto)) {
+    fail('native.auto must be "off", "report", or "on".');
+  }
+  checkPrefetch(native.prefetch, "native.", check);
+  if (native.islands !== void 0) {
+    if (!Array.isArray(native.islands) || !native.islands.every((entry) => typeof entry === "string" && ISLAND_NAME.test(entry))) {
+      fail('native.islands must be an array of component names, such as ["Map", "Video"].');
+    }
+  }
+  if (native.budgets !== void 0) {
+    if (!isPlainObject(native.budgets)) {
+      fail("native.budgets must be an object, such as { screenOpenMs: 300 }.");
+    }
+    checkKeys(native.budgets, BUDGET_KEYS, "native.budgets.");
+    for (const [key, value] of Object.entries(native.budgets)) {
+      if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+        fail(`native.budgets.${key} must be a number of 0 or more.`);
+      }
+    }
+  }
+  if (native.routes === void 0) return;
+  if (!isPlainObject(native.routes)) {
+    fail(
+      'native.routes must be an object keyed by route, such as { "/notes/new": { presentation: "modal" } }.'
+    );
+  }
+  for (const [pattern, route] of Object.entries(native.routes)) {
+    const where = `native.routes["${pattern}"]`;
+    checkRouteKey(pattern, where, check);
+    if (!isPlainObject(route)) fail(`${where} must be an object, such as { screen: "native" }.`);
+    if (typeof route.native === "string") fail(nativeModuleMovedMessage(where, pattern));
+    checkKeys(route, NATIVE_ROUTE_KEYS, `${where}.`);
+    if (route.screen === void 0) {
+      fail(`${where}.screen is required: "web", "native", or "platform".`);
+    }
+    for (const field of ["screen", "android", "ios"]) {
+      if (route[field] !== void 0 && !SCREENS.has(route[field])) {
+        fail(`${where}.${field} must be "web", "native", or "platform".`);
+      }
+    }
+    checkPresentation(route.presentation, where, check);
+  }
+}
+function validateFarmMobilePageConfig(value, where, context) {
+  const check = mobileChecker(context);
+  const { checkKeys } = check;
+  function fail(message) {
+    return check.fail(message);
+  }
+  if (!isPlainObject(value)) {
+    fail(`${where}: export const mobile must be an object, such as { presentation: "modal" }.`);
+  }
+  checkKeys(value, PAGE_KEYS, `${where}: mobile.`);
+  checkPresentation(value.presentation, `${where}: mobile`, check);
+  checkPrefetch(value.prefetch, `${where}: mobile.`, check);
+  if (value.native !== void 0 && typeof value.native !== "boolean") {
+    fail(`${where}: mobile.native must be true or false.`);
+  }
+  return value;
+}
+function validateFarmMobileConfig(input, context) {
+  const check = mobileChecker(context);
+  const { checkKeys, optionalString } = check;
+  function fail(message) {
+    return check.fail(message);
+  }
+  if (input === void 0) return void 0;
+  if (!isPlainObject(input)) {
+    fail(
+      context ? 'the function must return an object, such as { id: "com.example.notes" }.' : 'must be an object, such as { id: "com.example.notes" }, or a function that returns one.'
+    );
+  }
+  checkKeys(input, MOBILE_KEYS, "");
+  optionalString(input.name, "name");
+  const id = optionalString(input.id, "id");
+  if (id !== void 0) checkAppId(id, check);
+  const server = optionalString(input.server, "server");
+  if (server !== void 0) resolveFarmMobileServer(server, context ?? { command: "build" }, check);
+  if (input.tabs !== void 0) {
+    if (!Array.isArray(input.tabs)) {
+      fail('tabs must be an array, such as [{ path: "/", title: "Home", icon: "home" }].');
+    }
+    const tabs = input.tabs;
+    if (tabs.length > MAX_TABS) {
+      fail(`tabs has ${tabs.length} entries; a tab bar shows at most ${MAX_TABS}.`);
+    }
+    const seen = /* @__PURE__ */ new Set();
+    tabs.forEach((tab, index) => {
+      const where = `tabs[${index}]`;
+      if (!isPlainObject(tab)) {
+        fail(`${where} must be an object, such as { path: "/", title: "Home", icon: "home" }.`);
+      }
+      checkKeys(tab, TAB_KEYS, `${where}.`);
+      const { path: tabPath, title, icon } = tab;
+      if (typeof tabPath !== "string" || !tabPath.startsWith("/")) {
+        fail(`${where}.path must be a route path such as "/notes".`);
+      }
+      if (/[[\]()?#]/.test(tabPath)) {
+        fail(`${where}.path must be a static route such as "/notes", got "${tabPath}".`);
+      }
+      if (seen.has(tabPath)) fail(`${where}.path "${tabPath}" is already a tab.`);
+      seen.add(tabPath);
+      if (optionalString(title, `${where}.title`) === void 0) {
+        fail(`${where}.title must be a non-empty string.`);
+      }
+      const iconName = optionalString(icon, `${where}.icon`);
+      if (iconName === void 0 || !ICON_NAME.test(iconName)) {
+        fail(
+          `${where}.icon must be an icon name such as "note.text" or "ic_notes", got "${String(icon)}".`
+        );
+      }
+    });
+  }
+  if (input.routes !== void 0) {
+    if (!isPlainObject(input.routes)) {
+      fail(
+        'routes must be an object keyed by route, such as { "/notes/new": { presentation: "modal" } }.'
+      );
+    }
+    for (const [pattern, route] of Object.entries(input.routes)) {
+      const where = `routes["${pattern}"]`;
+      checkRouteKey(pattern, where, check);
+      if (!isPlainObject(route)) {
+        fail(`${where} must be an object, such as { presentation: "modal" }.`);
+      }
+      if (route.native !== void 0) fail(nativeModuleMovedMessage(where, pattern));
+      checkKeys(route, ROUTE_KEYS, `${where}.`);
+      checkPresentation(route.presentation, where, check);
+    }
+  }
+  if (input.native !== void 0) validateNativeConfig(input.native, check);
+  if (input.shells !== void 0 && typeof input.shells !== "boolean") {
+    fail("shells must be true or false.");
+  }
+  if (input.modules !== void 0 && !isPlainObject(input.modules)) {
+    fail(
+      'modules must be an object keyed by module name, such as { Device: { permissions: ["android.permission.VIBRATE"] } }.'
+    );
+  }
+  if (isPlainObject(input.routes) && isPlainObject(input.native)) {
+    const nativeRoutes = isPlainObject(input.native.routes) ? input.native.routes : {};
+    const presented = new Map(
+      Object.entries(input.routes).filter(([, route]) => isPlainObject(route) && route.presentation !== void 0).map(([pattern]) => [stripRouteGroupsFromPattern(pattern), pattern])
+    );
+    for (const [pattern, route] of Object.entries(nativeRoutes)) {
+      const other = presented.get(stripRouteGroupsFromPattern(pattern));
+      if (other !== void 0 && isPlainObject(route) && route.presentation !== void 0) {
+        fail(
+          `routes["${other}"].presentation and native.routes["${pattern}"].presentation set the same field. Keep one.`
+        );
+      }
+    }
+  }
+  return input;
+}
+function stripRouteGroupsFromPattern(pattern) {
+  const segments = pattern.split("/").filter((segment) => segment && !(segment.startsWith("(") && segment.endsWith(")")));
+  return segments.length === 0 ? "/" : `/${segments.join("/")}`;
+}
+function safeShape(pattern) {
+  try {
+    return getRoutePatternShape(pattern);
+  } catch {
+    return void 0;
+  }
+}
+function resolveFarmMobileConfig(input, options, context) {
+  const config = validateFarmMobileConfig(input, context) ?? {};
+  const check = mobileChecker(context);
+  function fail(message) {
+    return check.fail(message);
+  }
+  const pages = new Set(options.routes.map(stripRouteGroupsFromPattern));
+  const byShape = /* @__PURE__ */ new Map();
+  for (const page of pages) {
+    const shape = safeShape(page);
+    if (shape) byShape.set(shape, page);
+  }
+  const tabs = (config.tabs ?? []).map((tab, index) => {
+    const tabPath = stripRouteGroupsFromPattern(tab.path);
+    if (!pages.has(tabPath)) {
+      fail(
+        `tabs[${index}].path "${tab.path}" is not a page route. Add src/app${tabPath === "/" ? "" : tabPath}/page.tsx or pick an existing route.`
+      );
+    }
+    return { path: tabPath, title: tab.title.trim(), icon: tab.icon.trim() };
+  });
+  const tabPaths = new Set(tabs.map((tab) => tab.path));
+  const checkPage = (key, where) => {
+    const pattern = stripRouteGroupsFromPattern(key);
+    if (!pages.has(pattern)) {
+      const shape = safeShape(pattern);
+      const sameShape = shape ? byShape.get(shape) : void 0;
+      fail(
+        sameShape ? `${where} is not a page route; did you mean "${sameShape}"?` : `${where} is not a page route. Keys are app route patterns such as "/notes/[id]".`
+      );
+    }
+    return pattern;
+  };
+  const checkTabPresentation = (pattern, where, presentation) => {
+    if (presentation !== void 0 && tabPaths.has(pattern)) {
+      fail(`${where}.presentation does not apply to a tab route; tabs switch in place.`);
+    }
+  };
+  const routes = {};
+  for (const [key, route] of Object.entries(config.routes ?? {})) {
+    const where = `routes["${key}"]`;
+    const pattern = checkPage(key, where);
+    checkTabPresentation(pattern, where, route.presentation);
+    routes[pattern] = route.presentation ? { presentation: route.presentation } : {};
+  }
+  const native = config.native ?? {};
+  const nativeRoutes = {};
+  for (const [key, route] of Object.entries(native.routes ?? {})) {
+    const where = `native.routes["${key}"]`;
+    const pattern = checkPage(key, where);
+    checkTabPresentation(pattern, where, route.presentation);
+    nativeRoutes[pattern] = Object.fromEntries(
+      ["screen", "android", "ios", "presentation"].filter((field) => route[field] !== void 0).map((field) => [field, route[field]])
+    );
+  }
+  const pkg = readAppPackageJson(options.root);
+  const name = config.name?.trim() || resolveAppPackageName(options.root, pkg) || "Farm App";
+  const idName = name.replace(/[^A-Za-z0-9]+/g, "").replace(/^[^A-Za-z]+/, "") || "app";
+  const id = config.id?.trim() || `local.farm.${idName.toLowerCase()}`;
+  if (!config.id?.trim()) {
+    checkAppId(id, {
+      ...check,
+      fail: (message) => fail(
+        `${message} It comes from the app's name; set mobile.id, such as "com.example.notes".`
+      )
+    });
+  }
+  return {
+    name,
+    id,
+    ...config.server ? { server: resolveFarmMobileServer(config.server, context) } : {},
+    tabs,
+    routes,
+    native: {
+      engine: native.engine ?? "react-native",
+      auto: native.auto ?? "report",
+      routes: nativeRoutes,
+      islands: [...new Set(native.islands ?? [])].sort(),
+      prefetch: native.prefetch ?? "intent",
+      budgets: { ...native.budgets }
+    },
+    shells: config.shells === true,
+    modules: resolveFarmMobileModules(config.modules, options, fail)
+  };
+}
+function createFarmMobileContext(options) {
+  const os = options.os ?? "android";
+  if (!MOBILE_OS.has(os)) throw new TypeError(`--os must be android or ios, got "${os}".`);
+  if (options.command !== "dev" && options.command !== "build") {
+    throw new TypeError(`--command must be dev or build, got "${options.command}".`);
+  }
+  return Object.freeze({
+    os,
+    mode: options.mode,
+    command: options.command,
+    profile: resolvePlatformProfile(options.profile),
+    env: Object.freeze({ ...process.env }),
+    root: options.root
+  });
+}
+function resolveFarmMobileBlock(input, context, cache) {
+  return resolvePlatformBlock(
+    input,
+    context,
+    (value, ctx) => validateFarmMobileConfig(value, ctx) ?? {},
+    cache
+  );
+}
+
+// src/mobile/report.ts
+function createFarmMobileNativeReport(options) {
+  const summary = {
+    routes: 0,
+    analyzed: 0,
+    port: 0,
+    portableNoWin: 0,
+    blocked: 0,
+    native: 0,
+    tiers: { native: 0, "react-native": 0, web: 0 }
+  };
+  const routes = options.routes.map((route) => {
+    const decision = options.screens[route];
+    const analyzed = options.analysis[route];
+    summary.routes += 1;
+    if (decision.screen !== "web") summary.native += 1;
+    if (analyzed) {
+      summary.analyzed += 1;
+      summary.tiers[analyzed.tier] += 1;
+      if (analyzed.decision === "port") summary.port += 1;
+      else if (analyzed.portable) summary.portableNoWin += 1;
+      else summary.blocked += 1;
+    }
+    const { route: _route, ...analysis } = analyzed ?? {};
+    return {
+      route,
+      screen: decision.screen,
+      source: decision.source,
+      ...decision.requested ? { requested: decision.requested } : {},
+      ...decision.file ? { file: decision.file } : {},
+      ...analyzed ? { analysis } : {}
+    };
+  });
+  return {
+    version: 1,
+    os: options.os,
+    engine: options.engine,
+    auto: options.auto,
+    summary,
+    routes
+  };
+}
+function reasonFor(entry) {
+  const analysis = entry.analysis;
+  if (!analysis) {
+    if (entry.source === "page") {
+      return `${entry.file}: mobile.native ${entry.requested ? "true" : "false"}`;
+    }
+    if (entry.source === "file") return entry.file;
+    if (entry.source === "config") {
+      return entry.file ? `native.routes, ${entry.file}` : "native.routes";
+    }
+    return "";
+  }
+  if (analysis.tier === "native") return "renders natively, no JavaScript on the device";
+  if (analysis.portable) {
+    return analysis.wins.length > 0 ? `portable; ${analysis.wins.join(", ")}` : `portable; no win (${analysis.elements.total} elements)`;
+  }
+  const [first, ...rest] = analysis.nativeBlockers.length ? analysis.nativeBlockers : analysis.blockers;
+  const where = first.file ? `${first.file}:${first.line}:${first.column} ` : "";
+  return `${where}${first.message}${rest.length > 0 ? ` (+${rest.length} more)` : ""}`;
+}
+function formatFarmMobileNativeReport(report, options = {}) {
+  const rows = report.routes.map((entry) => [
+    entry.route,
+    entry.screen,
+    entry.analysis ? entry.analysis.tier : "-",
+    entry.analysis ? entry.analysis.decision : "-",
+    entry.analysis ? `${entry.analysis.elements.mapped}/${entry.analysis.elements.total}` : "",
+    entry.analysis ? `${entry.analysis.portablePercent}%` : "",
+    reasonFor(entry)
+  ]);
+  const header = ["route", "screen", "tier", "decision", "mapped", "portable", "reason"];
+  const widths = header.map(
+    (title, column) => Math.min(
+      column === 0 ? 40 : 12,
+      Math.max(title.length, ...rows.map((row) => row[column].length))
+    )
+  );
+  const line = (cells) => cells.map(
+    (cell, column) => column === cells.length - 1 ? cell : cell.padEnd(widths[column]).slice(0, widths[column])
+  ).join("  ").trimEnd();
+  const { summary } = report;
+  const lines = [
+    `mobile.native.auto: "${report.auto}" (os: ${report.os})`,
+    "",
+    line(header),
+    ...rows.map(line),
+    "",
+    `${summary.routes} routes: ${summary.port} port, ${summary.portableNoWin} portable without a win, ${summary.blocked} blocked, ${summary.native} native from files or config`,
+    `tiers: ${summary.tiers.native} native, ${summary.tiers["react-native"]} react-native, ${summary.tiers.web} web`
+  ];
+  if (options.stats) {
+    const { modules, parsed, cached, ms } = options.stats;
+    lines.push(`analyzed ${modules} modules (${parsed} parsed, ${cached} cached) in ${ms} ms`);
+  }
+  if (options.file) lines.push(`full report: ${options.file}`);
+  return lines.join("\n");
+}
+
+// src/mobile/screens.ts
+import * as path from "path";
+function createFarmMobileModuleId(route) {
+  return route === "/" ? "app" : `app${route}`;
+}
+function relativeFile(root, file) {
+  return path.relative(root, file).split(path.sep).join("/");
+}
+function resolveFarmMobileScreens(options) {
+  const { os, root } = options;
+  const { native } = options.mobile;
+  const prefix = `mobile (os: ${os})`;
+  const nativeTier = native.engine === "platform" ? "platform" : "native";
+  const platformFileName = os === "android" ? "page.kt" : "page.swift";
+  const screens = {};
+  const warnings = [];
+  for (const route of options.routes) {
+    const where = `native.routes["${route}"]`;
+    const routeConfig = native.routes[route];
+    const tier = routeConfig ? routeConfig[os] ?? routeConfig.screen : void 0;
+    const tierKey = routeConfig?.[os] !== void 0 ? os : "screen";
+    const page = options.pageExports?.get(route);
+    const files = options.nativePages?.get(route) ?? {};
+    const reactFile = files[os] ?? files.native;
+    const platformFile = os === "android" ? files.kt : files.swift;
+    const module = createFarmMobileModuleId(route);
+    if (native.engine === "platform") {
+      const reactNative = files.native ?? files.ios ?? files.android;
+      if (reactNative) {
+        throw new TypeError(
+          `${prefix}: ${relativeFile(root, reactNative)} is a React Native screen, but native.engine is "platform" (no React Native). Remove the file or use ${platformFileName}.`
+        );
+      }
+    }
+    if (reactFile && platformFile) {
+      throw new TypeError(
+        `${prefix}: "${route}" has two screens on ${os}: ${relativeFile(root, reactFile)} and ${relativeFile(root, platformFile)}. Keep one.`
+      );
+    }
+    const configPresentation = options.mobile.routes[route]?.presentation ?? routeConfig?.presentation;
+    if (page?.config.presentation !== void 0 && configPresentation !== void 0) {
+      warnings.push(
+        `${page.file}: mobile.presentation "${page.config.presentation}" overrides the config's "${configPresentation}" for "${route}".`
+      );
+    }
+    const base = {
+      presentation: page?.config.presentation ?? configPresentation ?? "push",
+      prefetch: page?.config.prefetch ?? native.prefetch
+    };
+    if (options.nativeOnlyRoutes?.has(route)) {
+      if (tier === "web") {
+        throw new TypeError(
+          `${prefix}: ${where}.${tierKey} is "web", but "${route}" is native-only: it has ${relativeFile(root, reactFile ?? platformFile)} and no page.tsx, so there is no web screen. Add the page, or remove the config route.`
+        );
+      }
+      const file2 = reactFile ?? platformFile;
+      if (!file2) {
+        throw new TypeError(`${prefix}: "${route}" is native-only but has no screen file.`);
+      }
+      screens[route] = {
+        screen: reactFile ? "native" : "platform",
+        source: "file",
+        file: relativeFile(root, file2),
+        module,
+        nativeOnly: true,
+        ...base
+      };
+      continue;
+    }
+    if (page?.config.native === false) {
+      if (tier !== void 0 && tier !== "web") {
+        warnings.push(
+          `${page.file}: mobile.native false overrides ${where}.${tierKey} "${tier}"; the route stays web.`
+        );
+      }
+      for (const unused of [reactFile, platformFile]) {
+        if (unused) {
+          warnings.push(
+            `${relativeFile(root, unused)} is unused: ${page.file} sets mobile.native to false.`
+          );
+        }
+      }
+      screens[route] = { screen: "web", source: "page", file: page.file, ...base };
+      continue;
+    }
+    if (page?.config.native === true) {
+      if (tier !== void 0 && tier !== "native") {
+        warnings.push(`${page.file}: mobile.native true overrides ${where}.${tierKey} "${tier}".`);
+      }
+      const file2 = reactFile ?? platformFile;
+      if (file2) {
+        screens[route] = {
+          screen: reactFile ? "native" : "platform",
+          source: "page",
+          file: relativeFile(root, file2),
+          module,
+          ...base
+        };
+        continue;
+      }
+      const analysis = options.analyzerTiers?.get(route);
+      if (analysis && analysis.tier !== "native") {
+        throw new TypeError(
+          `${prefix}: ${page.file} sets mobile.native to true, but "${route}" cannot render as a native screen:
+${analysis.nativeBlockers.map((blocker) => `  - ${blocker}`).join("\n")}
+` + (analysis.tier === "react-native" ? "It needs JavaScript on the device: add page.native.tsx next to the page, or " : "Remove the blockers, add page.native.tsx next to the page, or ") + "remove mobile.native."
+        );
+      }
+      screens[route] = analysis ? { screen: "server", source: "page", file: page.file, module, ...base } : { screen: "web", source: "page", file: page.file, requested: "native", ...base };
+      continue;
+    }
+    if (tier === "web") {
+      screens[route] = { screen: "web", source: "config", ...base };
+      continue;
+    }
+    if (tier === "platform" || tier === "native" && nativeTier === "platform" && platformFile) {
+      if (!platformFile) {
+        throw new TypeError(
+          `${prefix}: ${where}.${tierKey} is "platform", which needs ${platformFileName} next to the route's page.tsx.`
+        );
+      }
+      screens[route] = {
+        screen: "platform",
+        source: "config",
+        file: relativeFile(root, platformFile),
+        module,
+        ...base
+      };
+      continue;
+    }
+    if (tier === "native") {
+      if (nativeTier === "native" && reactFile) {
+        screens[route] = {
+          screen: "native",
+          source: "config",
+          file: relativeFile(root, reactFile),
+          module,
+          ...base
+        };
+        continue;
+      }
+      if (options.analyzerTiers?.get(route)?.tier === "native") {
+        screens[route] = { screen: "server", source: "config", module, ...base };
+        continue;
+      }
+      const portFile = options.portFiles?.get(route);
+      if (nativeTier === "native" && portFile) {
+        screens[route] = {
+          screen: "native",
+          source: "config",
+          file: relativeFile(root, portFile),
+          module,
+          ...base
+        };
+        continue;
+      }
+      const blockers = options.analyzerBlockers?.get(route);
+      const problems = options.portProblems?.get(route);
+      warnings.push(
+        `${where}.${tierKey} is "native", but "${route}" has no ${nativeTier === "native" ? "page.native.tsx" : platformFileName} and Farm cannot port it yet, so it stays web` + (blockers?.length ? `. The analyzer would keep it web: ${blockers.join("; ")}` : "") + (problems?.length ? `. The port would need: ${problems.join("; ")}` : "") + ". This fails the build once native screens ship."
+      );
+      screens[route] = { screen: "web", source: "config", requested: nativeTier, ...base };
+      continue;
+    }
+    const file = reactFile ?? platformFile;
+    if (file) {
+      screens[route] = {
+        screen: reactFile ? "native" : "platform",
+        source: "file",
+        file: relativeFile(root, file),
+        module,
+        ...base
+      };
+      continue;
+    }
+    if (native.auto === "on" && options.analyzerTiers?.get(route)?.tier === "native") {
+      screens[route] = { screen: "server", source: "analyzer", module, ...base };
+      continue;
+    }
+    if (native.auto === "on" && options.analyzerPorts?.has(route)) {
+      const portFile = options.portFiles?.get(route);
+      if (nativeTier === "native" && portFile) {
+        screens[route] = {
+          screen: "native",
+          source: "analyzer",
+          file: relativeFile(root, portFile),
+          module,
+          ...base
+        };
+        continue;
+      }
+      const problems = options.portProblems?.get(route);
+      if (problems?.length) {
+        warnings.push(
+          `${prefix}: "${route}" is portable, but Farm cannot port it yet, so it stays web: ${problems.join("; ")}.`
+        );
+      }
+      screens[route] = { screen: "web", source: "analyzer", requested: nativeTier, ...base };
+      continue;
+    }
+    screens[route] = { screen: "web", source: "default", ...base };
+  }
+  return { screens, warnings };
+}
+function unwrap(node) {
+  let current = node;
+  while (current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression" || current.type === "ParenthesizedExpression") {
+    current = current.expression;
+  }
+  return current;
+}
+function literalValue(node, fail) {
+  const value = unwrap(node);
+  if (value.type === "Literal") return value.value;
+  if (value.type === "ObjectExpression") {
+    const result = {};
+    for (const property of value.properties) {
+      const key = property.key;
+      if (property.type !== "Property" || property.computed || !key) {
+        fail("must be an object literal without spreads or computed keys");
+      }
+      const name = key.type === "Identifier" ? key.name : key.value;
+      if (typeof name !== "string") fail("must use plain keys");
+      result[name] = literalValue(property.value, fail);
+    }
+    return result;
+  }
+  return fail('must use literal values, such as { presentation: "modal" }');
+}
+function readFarmMobilePageExport(source, file, parse, context) {
+  if (!/\bmobile\b/.test(source)) return void 0;
+  const prefix = context ? `mobile (os: ${context.os})` : "mobile";
+  const fail = (message) => {
+    throw new TypeError(
+      `${prefix}: ${file}: export const mobile ${message}. Farm reads it without running the page.`
+    );
+  };
+  for (const statement of parse(file, source).body) {
+    if (statement.type !== "ExportNamedDeclaration") continue;
+    for (const specifier of statement.specifiers ?? []) {
+      const exported = specifier.exported;
+      if ((exported.name ?? exported.value) === "mobile") {
+        fail("must be declared in place, as export const mobile = { ... }");
+      }
+    }
+    const declaration = statement.declaration;
+    if (!declaration) continue;
+    if (declaration.type === "VariableDeclaration") {
+      for (const declarator of declaration.declarations) {
+        const id = declarator.id;
+        if (id.type !== "Identifier" || id.name !== "mobile") continue;
+        if (declaration.kind !== "const") fail("must be a const");
+        if (!declarator.init) fail("needs a value");
+        const value = literalValue(declarator.init, fail);
+        return validateFarmMobilePageConfig(value, file, context);
+      }
+    } else if (declaration.id?.name === "mobile") {
+      fail('must be an object, such as export const mobile = { presentation: "modal" }');
+    }
+  }
+  return void 0;
+}
+
+// src/mobile/routes.ts
+var REGEX_SPECIAL = /[\\^$.|?*+()[\]{}]/g;
+function escapeRegex(value) {
+  return value.replace(REGEX_SPECIAL, "\\$&");
+}
+function caseInsensitive(value) {
+  return Array.from(value).map((character) => {
+    const lower = character.toLowerCase();
+    const upper = character.toUpperCase();
+    return lower === upper ? escapeRegex(character) : `[${upper}${lower}]`;
+  }).join("");
+}
+function decodeSegment(segment) {
+  try {
+    return decodeURIComponent(segment);
+  } catch {
+    return segment;
+  }
+}
+function createFarmMobileRoutePattern(pattern, options = {}) {
+  let source = `^${escapeRegex(normalizeFarmBasePath(options.basePath))}`;
+  const i18n = options.i18n;
+  if (i18n && i18n.routing !== "none" && i18n.locales.length > 0) {
+    const locale = `/(?:${i18n.locales.map(caseInsensitive).join("|")})`;
+    source += `(?:${locale}|(?!${locale}(?:/|$)))`;
+  }
+  for (const segment of pattern.split("/").filter(Boolean)) {
+    if (segment.startsWith("(") && segment.endsWith(")")) continue;
+    if (segment.startsWith("[[...") && segment.endsWith("]]")) source += "(?:/[^/]+)*";
+    else if (segment.startsWith("[...") && segment.endsWith("]")) source += "(?:/[^/]+)+";
+    else if (segment.startsWith("[") && segment.endsWith("]")) source += "/[^/]+";
+    else source += `/${escapeRegex(decodeSegment(segment))}`;
+  }
+  return `${source}/?$`;
+}
+function stripRouteGroups(pattern) {
+  const segments = pattern.split("/").filter((segment) => segment && !(segment.startsWith("(") && segment.endsWith(")")));
+  return segments.length === 0 ? "/" : `/${segments.join("/")}`;
+}
+function createFarmMobileRouteManifest(mobile, options) {
+  const server = options.server ?? mobile.server;
+  if (!server) {
+    throw new TypeError(
+      'mobile: server is required, such as server: "https://notes.example.com" (the web deployment the app loads pages from).'
+    );
+  }
+  const basePath = normalizeFarmBasePath(options.basePath);
+  const tabIndex = new Map(mobile.tabs.map((tab, index) => [tab.path, index]));
+  const routes = [...new Set(options.routes.map(stripRouteGroups))].sort().sort((left, right) => compareRoutePatternSpecificity(left, right));
+  const screens = options.screens ?? resolveFarmMobileScreens({ root: "", os: options.os ?? "android", routes, mobile }).screens;
+  const rules = routes.map((route) => {
+    const decision = screens[route] ?? {
+      screen: "web",
+      source: "default",
+      presentation: "push",
+      prefetch: mobile.native.prefetch
+    };
+    const tab = tabIndex.get(route);
+    return {
+      route,
+      pattern: createFarmMobileRoutePattern(route, options),
+      presentation: tab !== void 0 ? "tab" : decision.presentation,
+      ...tab !== void 0 ? { tab } : {},
+      screen: decision.screen,
+      source: decision.source,
+      ...decision.module ? { module: decision.module } : {},
+      ...decision.nativeOnly ? { nativeOnly: true } : {},
+      ...decision.prefetch !== mobile.native.prefetch ? { prefetch: decision.prefetch } : {}
+    };
+  });
+  rules.push({ pattern: "^/", presentation: "push", screen: "web" });
+  return {
+    version: 1,
+    server,
+    tabs: mobile.tabs.map((tab) => ({
+      ...tab,
+      path: basePath ? tab.path === "/" ? basePath : `${basePath}${tab.path}` : tab.path
+    })),
+    prefetch: mobile.native.prefetch,
+    rules,
+    ...options.shells && Object.keys(options.shells.routes).length > 0 ? { shells: { client: options.shells.client, routes: { ...options.shells.routes } } } : {}
+  };
+}
+
+// src/mobile/page-shells.ts
+import { createHash } from "crypto";
+var SCRIPT = /<script\b[^>]*>[\s\S]*?<\/script\s*>/gi;
+var LINK = /<link\b[^>]*>/gi;
+var REMOVED = "\0";
+var REMOVED_ALL = /\u0000/g;
+var REMOVED_LINE = /\n[ \t\u0000]*\u0000[ \t\u0000]*(?=\n|$)/g;
+var HEAD = /<head\b[^>]*>[\s\S]*?<\/head\s*>/i;
+var BLANK_LINE = /\n[ \t]*(?=\n)/g;
+function attribute(tag, name) {
+  const match = tag.match(
+    new RegExp(`\\s${name}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s"'>]+))`, "i")
+  );
+  if (!match) return void 0;
+  return (match[1] ?? match[2] ?? match[3] ?? "").replace(/&amp;/g, "&");
+}
+function relList(tag) {
+  return (attribute(tag, "rel") ?? "").toLowerCase().split(/\s+/).filter(Boolean);
+}
+function inlineStyle(css, media) {
+  const safeMedia = media && /^[\w\s(),:.-]+$/.test(media) ? ` media="${media}"` : "";
+  return `<style${safeMedia}>${css.replace(/<\/(style)/gi, "<\\/$1")}</style>`;
+}
+function createFarmMobilePageShell(html, options) {
+  let shell = html.replace(REMOVED_ALL, "").replace(SCRIPT, REMOVED);
+  shell = shell.replace(LINK, (tag) => {
+    const rel = relList(tag);
+    if (rel.includes("modulepreload") || rel.includes("preload") && (attribute(tag, "as") ?? "").toLowerCase() === "script" || !rel.includes("stylesheet") && (rel.includes("canonical") || rel.includes("alternate"))) {
+      return REMOVED;
+    }
+    if (options.os !== "ios" || !rel.includes("stylesheet")) return tag;
+    const href = attribute(tag, "href");
+    const css = href === void 0 ? void 0 : options.readStylesheet?.(href);
+    return css === void 0 ? tag : inlineStyle(css, attribute(tag, "media"));
+  });
+  shell = shell.replace(REMOVED_LINE, "").replace(REMOVED_ALL, "");
+  shell = shell.replace(HEAD, (head) => head.replace(BLANK_LINE, ""));
+  return shell.replace(
+    /<html\b([^>]*)>/i,
+    (tag, attributes) => /\sdata-farm-page-shell\b/i.test(attributes) ? tag : `<html${attributes} data-farm-page-shell>`
+  );
+}
+function getFarmMobilePageShellFile(shell) {
+  return `${createHash("sha256").update(shell).digest("hex").slice(0, 16)}.html`;
+}
+async function renderFarmMobilePageShells(options) {
+  const routes = {};
+  const files = {};
+  const skipped = [];
+  const queue = [...new Set(options.routes)].sort();
+  const render = async (route) => {
+    const response = await options.fetch(
+      `${options.basePath}${createFarmMobileShellRenderPath(route)}`,
+      {
+        headers: {
+          Accept: "text/html",
+          [FARM_SHELL_HEADER]: options.os,
+          [FARM_SHELL_RENDER_HEADER]: options.token,
+          [FARM_SHELL_ROUTE_HEADER]: route
+        }
+      }
+    );
+    const body = await response.text();
+    if (response.headers.get(FARM_SHELL_RENDER_HEADER) === "none") {
+      skipped.push({ route, reason: body.trim() || "the server rendered no shell" });
+      return;
+    }
+    const type = response.headers.get("content-type")?.toLowerCase() ?? "";
+    if (response.status !== 200 || !type.includes("text/html")) {
+      const location = response.headers.get("location");
+      skipped.push({
+        route,
+        reason: `the server answered ${response.status}${location ? ` (to ${location})` : ""}`
+      });
+      return;
+    }
+    const shell = createFarmMobilePageShell(body, options);
+    const file = getFarmMobilePageShellFile(shell);
+    files[file] = shell;
+    routes[route] = file;
+  };
+  const workers = Array.from(
+    { length: Math.max(1, Math.min(options.concurrency ?? 4, queue.length)) },
+    async () => {
+      for (let route = queue.shift(); route !== void 0; route = queue.shift()) {
+        await render(route);
+      }
+    }
+  );
+  await Promise.all(workers);
+  skipped.sort((left, right) => left.route < right.route ? -1 : left.route > right.route ? 1 : 0);
+  return {
+    shells: {
+      client: options.client,
+      routes: Object.fromEntries(Object.entries(routes).sort(([a], [b]) => a < b ? -1 : 1)),
+      files: Object.fromEntries(Object.entries(files).sort(([a], [b]) => a < b ? -1 : 1))
+    },
+    skipped
+  };
+}
+
+// src/mobile/runtime.ts
+var FarmMobileError = class extends Error {
+  constructor() {
+    super(...arguments);
+    this.name = "FarmMobileError";
+  }
+};
+function getFarmMobileOutputDirs(distDir) {
+  const root = path2.join(distDir, "output", "mobile");
+  return {
+    root,
+    routes: path2.join(root, "farm-routes.json"),
+    www: path2.join(root, "www"),
+    android: path2.join(root, "android"),
+    ios: path2.join(root, "ios"),
+    dist: path2.join(root, "dist"),
+    report: path2.join(root, "native-report.json"),
+    ports: path2.join(root, "ports"),
+    analyzerCache: path2.join(distDir, "cache", "mobile", "analyzer.json"),
+    client: path2.join(distDir, "client")
+  };
+}
+var SCRIPT_PAGE = /\.(?:tsx|ts|jsx|js)$/;
+function describe(blocker) {
+  return `${blocker.file ? `${blocker.file}:${blocker.line}:${blocker.column} ` : ""}${blocker.message}`;
+}
+function scriptLang(file) {
+  return file.endsWith(".tsx") ? "tsx" : file.endsWith(".ts") ? "ts" : "jsx";
+}
+async function readPageExports(root, pageFiles, os) {
+  const exports = /* @__PURE__ */ new Map();
+  let parseSync;
+  await Promise.all(
+    [...pageFiles].map(async ([route, file]) => {
+      if (!SCRIPT_PAGE.test(file)) return;
+      const source = await readFile(file, "utf8");
+      if (!/\bmobile\b/.test(source)) return;
+      parseSync ?? (parseSync = (await import("rolldown/utils")).parseSync);
+      const parse = parseSync;
+      const relative3 = path2.relative(root, file).split(path2.sep).join("/");
+      const config = readFarmMobilePageExport(
+        source,
+        relative3,
+        (name, code) => parse(name, code, { lang: scriptLang(name) }).program,
+        { os }
+      );
+      if (config) exports.set(route, { file: relative3, config });
+    })
+  );
+  return exports;
+}
+async function resolveFarmMobileApp(options = {}) {
+  const root = path2.resolve(options.config?.root ?? options.root ?? process.cwd());
+  const command = options.command ?? "build";
+  const mode = command === "dev" ? "development" : "production";
+  const userConfig = options.userConfig === void 0 ? await loadConfig(root, void 0, mode) : options.userConfig;
+  if (userConfig?.mobile === void 0) {
+    throw new FarmMobileError(
+      'farm.config.ts has no `mobile` entry. Add one, such as `mobile: { id: "com.example.notes", server: "https://notes.example.com" }`.'
+    );
+  }
+  const context = createFarmMobileContext({
+    command,
+    profile: options.profile,
+    os: options.os,
+    root,
+    mode
+  });
+  const block = await resolveFarmMobileBlock(userConfig.mobile, context, options.cache);
+  const config = options.config ?? await resolveConfig({ ...userConfig, root }, mode);
+  const scan = await scanRoutePatterns({
+    root,
+    srcDir: config.srcDir,
+    sourceRoots: getFarmSourceRoots(config),
+    componentExtensions: getFarmRendererComponentExtensions(config.renderer),
+    platformFiles: true
+  });
+  const routes = [...scan.pages, ...scan.nativeOnlyPages].sort();
+  let appModules;
+  try {
+    appModules = scanFarmMobileAppModules({ root, srcDir: config.srcDir });
+  } catch (error) {
+    throw Object.assign(
+      new FarmMobileError(`mobile (os: ${context.os}): ${error.message}`),
+      { cause: error }
+    );
+  }
+  const mobile = resolveFarmMobileConfig(
+    block,
+    {
+      root,
+      srcDir: config.srcDir,
+      routes,
+      appModules: appModules?.specs.map((spec) => spec.name)
+    },
+    context
+  );
+  if (appModules && Object.values(mobile.modules).some((module) => module.web)) {
+    try {
+      appModules = readFarmMobileWebModules(appModules, mobile.modules, { root });
+    } catch (error) {
+      throw Object.assign(
+        new FarmMobileError(`mobile (os: ${context.os}): ${error.message}`),
+        { cause: error }
+      );
+    }
+  }
+  const pageExports = await readPageExports(root, scan.pageFiles, context.os);
+  for (const [route, page] of pageExports) {
+    if (page.config.presentation !== void 0 && mobile.tabs.some((tab) => tab.path === route)) {
+      throw new TypeError(
+        `mobile (os: ${context.os}): ${page.file}: mobile.presentation does not apply to a tab route; tabs switch in place.`
+      );
+    }
+  }
+  const screenOptions = {
+    root,
+    os: context.os,
+    routes,
+    mobile,
+    nativePages: scan.nativePages,
+    nativeOnlyRoutes: scan.nativeOnlyPages,
+    pageExports
+  };
+  let { screens, warnings } = resolveFarmMobileScreens(screenOptions);
+  let report;
+  let analyzerStats;
+  const ports = /* @__PURE__ */ new Map();
+  const portProblems = /* @__PURE__ */ new Map();
+  const asserted = [...pageExports.values()].some((page) => page.config.native === true);
+  const analyze = options.analyze === "always" || asserted || options.analyze === true && mobile.native.auto !== "off";
+  if (analyze) {
+    const candidates = routes.filter((route) => {
+      const decision = screens[route];
+      return decision.source === "default" || decision.requested !== void 0;
+    });
+    const portable = mobile.native.engine !== "platform" && (mobile.native.auto === "on" || candidates.some((route) => screens[route].requested === "native"));
+    const { analyzeFarmMobileRoutes } = await import("./analyzer-YESYU3GK.mjs");
+    const analyzed = await analyzeFarmMobileRoutes({
+      root,
+      srcDir: config.srcDir,
+      routes: portable ? routes : candidates,
+      pageFiles: scan.pageFiles,
+      nativeOnlyRoutes: scan.nativeOnlyPages,
+      serverComponents: resolveFarmServerComponentsMode(config.experimental?.serverComponents) !== void 0,
+      cacheFile: path2.resolve(root, getFarmMobileOutputDirs(config.distDir).analyzerCache)
+    });
+    analyzerStats = analyzed.stats;
+    const result = {
+      ...analyzed,
+      routes: Object.fromEntries(
+        candidates.flatMap(
+          (route) => analyzed.routes[route] ? [[route, analyzed.routes[route]]] : []
+        )
+      )
+    };
+    if (portable) {
+      const { emitFarmMobilePort } = await import("./port-UFUZL6RI.mjs");
+      const portsDir = path2.resolve(root, getFarmMobileOutputDirs(config.distDir).ports);
+      for (const analysis of Object.values(result.routes)) {
+        const graph = result.graphs[analysis.route];
+        const wanted = mobile.native.auto === "on" && analysis.decision === "port" || screens[analysis.route].requested === "native";
+        if (!graph || !wanted || analysis.tier === "native") continue;
+        const emitted = await emitFarmMobilePort({
+          root,
+          graph,
+          portsDir,
+          module: createFarmMobileModuleId(analysis.route),
+          stylesheets: result.stylesheets,
+          unreadStylesheets: result.unreadStylesheets
+        });
+        if ("problems" in emitted) portProblems.set(analysis.route, emitted.problems);
+        else ports.set(analysis.route, emitted.port);
+      }
+    }
+    ({ screens, warnings } = resolveFarmMobileScreens({
+      ...screenOptions,
+      portFiles: new Map(
+        [...ports].map(([route, port]) => [
+          route,
+          path2.resolve(root, getFarmMobileOutputDirs(config.distDir).ports, port.entry)
+        ])
+      ),
+      portProblems,
+      analyzerPorts: new Set(
+        Object.values(result.routes).filter((route) => route.decision === "port").map((route) => route.route)
+      ),
+      analyzerBlockers: new Map(
+        Object.values(result.routes).map((route) => [route.route, route.blockers.map(describe)])
+      ),
+      analyzerTiers: new Map(
+        Object.values(result.routes).map((route) => [
+          route.route,
+          { tier: route.tier, nativeBlockers: route.nativeBlockers.map(describe) }
+        ])
+      )
+    }));
+    report = createFarmMobileNativeReport({
+      os: context.os,
+      engine: mobile.native.engine,
+      auto: mobile.native.auto,
+      routes,
+      screens,
+      analysis: result.routes
+    });
+  }
+  const nativeLayouts = Object.fromEntries(
+    [...scan.nativeLayouts].sort().map(([route, files]) => [
+      route,
+      Object.fromEntries(
+        Object.entries(files).map(([platform, file]) => [
+          platform,
+          path2.relative(root, file).split(path2.sep).join("/")
+        ])
+      )
+    ])
+  );
+  const server = options.server === void 0 ? void 0 : resolveFarmMobileServer(options.server, context, void 0, "the server URL");
+  if (!server && !mobile.server) {
+    throw new FarmMobileError(
+      `mobile (os: ${context.os}): server is required, such as server: "https://notes.example.com" (the web deployment the app loads pages from).`
+    );
+  }
+  const i18n = config.i18n && typeof config.i18n === "object" && config.i18n.enabled ? { locales: config.i18n.locales, routing: config.i18n.routing } : null;
+  const manifest = createFarmMobileRouteManifest(mobile, {
+    routes,
+    server,
+    basePath: config.basePath,
+    i18n,
+    screens,
+    ...options.shells ? { shells: options.shells } : {}
+  });
+  return {
+    context,
+    mobile,
+    manifest,
+    config,
+    screens,
+    warnings,
+    nativeLayouts,
+    pageFiles: scan.pageFiles,
+    ports: Object.fromEntries(ports),
+    ...report ? { report, analyzerStats } : {},
+    ...appModules ? { appModules } : {}
+  };
+}
+async function generateFarmMobileRoutes(options = {}) {
+  const app = await resolveFarmMobileApp(options);
+  const dirs = getFarmMobileOutputDirs(app.config.distDir);
+  const file = path2.resolve(app.config.root, dirs.routes);
+  await mkdir(path2.dirname(file), { recursive: true });
+  await writeFile(file, `${JSON.stringify(app.manifest, null, 2)}
+`);
+  const portsDir = path2.resolve(app.config.root, dirs.ports);
+  await rm(portsDir, { recursive: true, force: true });
+  for (const port of Object.values(app.ports)) {
+    for (const [relative3, source] of Object.entries(port.files)) {
+      const target = path2.join(portsDir, relative3);
+      await mkdir(path2.dirname(target), { recursive: true });
+      await writeFile(target, source);
+    }
+  }
+  if (!app.report) return { ...app, file };
+  const reportFile = path2.resolve(app.config.root, dirs.report);
+  await writeFile(reportFile, `${JSON.stringify(app.report, null, 2)}
+`);
+  const table = formatFarmMobileNativeReport(app.report, {
+    stats: app.analyzerStats,
+    file: path2.relative(app.config.root, reportFile).split(path2.sep).join("/")
+  });
+  return { ...app, file, reportFile, table };
+}
+export {
+  FARM_SHELL_PARAM_SEGMENT,
+  FARM_SHELL_RENDER_HEADER,
+  FARM_SHELL_ROUTE_HEADER,
+  FarmMobileError,
+  createFarmMobileContext,
+  createFarmMobileModuleId,
+  createFarmMobilePageShell,
+  createFarmMobileRouteManifest,
+  createFarmMobileRoutePattern,
+  createFarmMobileShellRenderPath,
+  formatFarmMobileNativeReport,
+  generateFarmMobileRoutes,
+  getFarmMobileOutputDirs,
+  getFarmMobilePageShellFile,
+  readFarmMobileClientManifest,
+  readFarmMobilePageExport,
+  renderFarmMobilePageShells,
+  resolveFarmMobileApp,
+  resolveFarmMobileBlock,
+  resolveFarmMobileConfig,
+  resolveFarmMobileScreens,
+  validateFarmMobileConfig
+};