@farm.js/core 0.1.49 → 0.1.50

package/dist/runtime-BIBGJO7V.cjs

@@ -0,0 +1,1005 @@
+"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 _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 _chunkLYWAGXXWcjs = require('./chunk-LYWAGXXW.cjs');
+require('./chunk-OZC2JPW6.cjs');
+
+
+var _chunk3ATXWZPHcjs = require('./chunk-3ATXWZPH.cjs');
+
+
+
+
+
+
+
+var _chunkYKHRCY4Tcjs = require('./chunk-YKHRCY4T.cjs');
+require('./chunk-5YPBFMBN.cjs');
+
+
+var _chunkBPNOYILCcjs = require('./chunk-BPNOYILC.cjs');
+require('./chunk-V56632LA.cjs');
+require('./chunk-LSHX2H5G.cjs');
+require('./chunk-STF6VDYQ.cjs');
+
+
+var _chunkRD623KW4cjs = require('./chunk-RD623KW4.cjs');
+require('./chunk-NYQSC4DX.cjs');
+require('./chunk-SG57PX7K.cjs');
+require('./chunk-HIFIG6HL.cjs');
+require('./chunk-6JHZPB52.cjs');
+require('./chunk-HEPJIKKQ.cjs');
+require('./chunk-3EIPOTZV.cjs');
+
+
+var _chunk5Y2P454Ocjs = require('./chunk-5Y2P454O.cjs');
+require('./chunk-2HW5LWAH.cjs');
+require('./chunk-DQJ2CIH7.cjs');
+require('./chunk-IQXGHGZF.cjs');
+require('./chunk-C7425KDG.cjs');
+require('./chunk-2KMIJDY6.cjs');
+require('./chunk-6QA2SXVH.cjs');
+require('./chunk-WT6RAN2I.cjs');
+require('./chunk-WJFFPXCV.cjs');
+require('./chunk-SHIWRBFI.cjs');
+require('./chunk-WAPQWAE6.cjs');
+require('./chunk-DUIP64BF.cjs');
+require('./chunk-PFV2KPDZ.cjs');
+require('./chunk-ZXK2EYQW.cjs');
+require('./chunk-J2ZEVDEK.cjs');
+require('./chunk-5DX3O6TT.cjs');
+require('./chunk-JZMZKABS.cjs');
+require('./chunk-6ONBZGVH.cjs');
+require('./chunk-E7QOEV5Z.cjs');
+require('./chunk-OYZXVBZP.cjs');
+require('./chunk-ITV4QQL2.cjs');
+require('./chunk-FEFCISOX.cjs');
+require('./chunk-LNVGXUL3.cjs');
+require('./chunk-XN2MB4QZ.cjs');
+require('./chunk-JHXJBNLY.cjs');
+require('./chunk-EVIWKPJV.cjs');
+require('./chunk-Z5MZDFX4.cjs');
+require('./chunk-LIFUPCXW.cjs');
+require('./chunk-JYT7AN37.cjs');
+require('./chunk-B5BBTPJQ.cjs');
+require('./chunk-HA7YRO53.cjs');
+require('./chunk-CA7DNRHO.cjs');
+require('./chunk-IWFV5ZED.cjs');
+require('./chunk-6FXBJPF5.cjs');
+require('./chunk-E552H232.cjs');
+require('./chunk-UZCMMJJT.cjs');
+require('./chunk-6XQSPIN6.cjs');
+require('./chunk-7JUIK547.cjs');
+require('./chunk-A25FXJ7D.cjs');
+require('./chunk-6CTFVBAT.cjs');
+require('./chunk-3BIASUGR.cjs');
+require('./chunk-OWQV6MLM.cjs');
+
+
+var _chunkD22BUQKWcjs = require('./chunk-D22BUQKW.cjs');
+
+
+
+var _chunkYTVSWXEZcjs = require('./chunk-YTVSWXEZ.cjs');
+require('./chunk-BTZ5O6VM.cjs');
+
+// src/mobile/runtime.ts
+var _promises = require('fs/promises');
+var _path = require('path'); var path2 = _interopRequireWildcard(_path); var path = _interopRequireWildcard(_path);
+
+// src/mobile/config.ts
+var MOBILE_KEYS = /* @__PURE__ */ new Set(["name", "id", "server", "tabs", "routes", "native"]);
+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 _chunkYKHRCY4Tcjs.createPlatformBlockChecker.call(void 0, 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 (e) {
+    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 (!_chunkYKHRCY4Tcjs.isPlainObject.call(void 0, 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 (!_chunkYKHRCY4Tcjs.isPlainObject.call(void 0, 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 (!_chunkYKHRCY4Tcjs.isPlainObject.call(void 0, 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 (!_chunkYKHRCY4Tcjs.isPlainObject.call(void 0, 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 (!_chunkYKHRCY4Tcjs.isPlainObject.call(void 0, 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 && value.native !== false) {
+    fail(
+      `${where}: mobile.native can only be false. A native screen comes from a page.native.tsx next to the page.`
+    );
+  }
+  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 (!_chunkYKHRCY4Tcjs.isPlainObject.call(void 0, 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, _nullishCoalesce(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 (!_chunkYKHRCY4Tcjs.isPlainObject.call(void 0, 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 (!_chunkYKHRCY4Tcjs.isPlainObject.call(void 0, 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 (!_chunkYKHRCY4Tcjs.isPlainObject.call(void 0, 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 (_chunkYKHRCY4Tcjs.isPlainObject.call(void 0, input.routes) && _chunkYKHRCY4Tcjs.isPlainObject.call(void 0, input.native)) {
+    const nativeRoutes = _chunkYKHRCY4Tcjs.isPlainObject.call(void 0, input.native.routes) ? input.native.routes : {};
+    const presented = new Map(
+      Object.entries(input.routes).filter(([, route]) => _chunkYKHRCY4Tcjs.isPlainObject.call(void 0, 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 && _chunkYKHRCY4Tcjs.isPlainObject.call(void 0, 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 _chunkYTVSWXEZcjs.getRoutePatternShape.call(void 0, pattern);
+  } catch (e2) {
+    return void 0;
+  }
+}
+function resolveFarmMobileConfig(input, options, context) {
+  const config = _nullishCoalesce(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 = (_nullishCoalesce(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(_nullishCoalesce(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 = _nullishCoalesce(config.native, () => ( {}));
+  const nativeRoutes = {};
+  for (const [key, route] of Object.entries(_nullishCoalesce(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 = _chunkYKHRCY4Tcjs.readAppPackageJson.call(void 0, options.root);
+  const name = _optionalChain([config, 'access', _ => _.name, 'optionalAccess', _2 => _2.trim, 'call', _3 => _3()]) || _chunkYKHRCY4Tcjs.resolveAppPackageName.call(void 0, options.root, pkg) || "Farm App";
+  const idName = name.replace(/[^A-Za-z0-9]+/g, "").replace(/^[^A-Za-z]+/, "") || "app";
+  const id = _optionalChain([config, 'access', _4 => _4.id, 'optionalAccess', _5 => _5.trim, 'call', _6 => _6()]) || `local.farm.${idName.toLowerCase()}`;
+  if (!_optionalChain([config, 'access', _7 => _7.id, 'optionalAccess', _8 => _8.trim, 'call', _9 => _9()])) {
+    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: _nullishCoalesce(native.engine, () => ( "react-native")),
+      auto: _nullishCoalesce(native.auto, () => ( "report")),
+      routes: nativeRoutes,
+      islands: [...new Set(_nullishCoalesce(native.islands, () => ( [])))].sort(),
+      prefetch: _nullishCoalesce(native.prefetch, () => ( "intent")),
+      budgets: { ...native.budgets }
+    }
+  };
+}
+function createFarmMobileContext(options) {
+  const os = _nullishCoalesce(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: _chunkYKHRCY4Tcjs.resolvePlatformProfile.call(void 0, options.profile),
+    env: Object.freeze({ ...process.env }),
+    root: options.root
+  });
+}
+function resolveFarmMobileBlock(input, context, cache) {
+  return _chunkYKHRCY4Tcjs.resolvePlatformBlock.call(void 0, 
+    input,
+    context,
+    (value, ctx) => _nullishCoalesce(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 };
+  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;
+      if (analyzed.decision === "port") summary.port += 1;
+      else if (analyzed.portable) summary.portableNoWin += 1;
+      else summary.blocked += 1;
+    }
+    const { route: _route, ...analysis } = _nullishCoalesce(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 false`;
+    if (entry.source === "file") return entry.file;
+    if (entry.source === "config") {
+      return entry.file ? `native.routes, ${entry.file}` : "native.routes";
+    }
+    return "";
+  }
+  if (analysis.portable) {
+    return analysis.wins.length > 0 ? `portable; ${analysis.wins.join(", ")}` : `portable; no win (${analysis.elements.total} elements)`;
+  }
+  const [first, ...rest] = 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.decision : "-",
+    entry.analysis ? `${entry.analysis.elements.mapped}/${entry.analysis.elements.total}` : "",
+    entry.analysis ? `${entry.analysis.portablePercent}%` : "",
+    reasonFor(entry)
+  ]);
+  const header = ["route", "screen", "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`
+  ];
+  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
+
+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 ? _nullishCoalesce(routeConfig[os], () => ( routeConfig.screen)) : void 0;
+    const tierKey = _optionalChain([routeConfig, 'optionalAccess', _10 => _10[os]]) !== void 0 ? os : "screen";
+    const page = _optionalChain([options, 'access', _11 => _11.pageExports, 'optionalAccess', _12 => _12.get, 'call', _13 => _13(route)]);
+    const files = _nullishCoalesce(_optionalChain([options, 'access', _14 => _14.nativePages, 'optionalAccess', _15 => _15.get, 'call', _16 => _16(route)]), () => ( {}));
+    const reactFile = _nullishCoalesce(files[os], () => ( files.native));
+    const platformFile = os === "android" ? files.kt : files.swift;
+    const module = createFarmMobileModuleId(route);
+    if (native.engine === "platform") {
+      const reactNative = _nullishCoalesce(_nullishCoalesce(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 = _nullishCoalesce(_optionalChain([options, 'access', _17 => _17.mobile, 'access', _18 => _18.routes, 'access', _19 => _19[route], 'optionalAccess', _20 => _20.presentation]), () => ( _optionalChain([routeConfig, 'optionalAccess', _21 => _21.presentation])));
+    if (_optionalChain([page, 'optionalAccess', _22 => _22.config, 'access', _23 => _23.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: _nullishCoalesce(_nullishCoalesce(_optionalChain([page, 'optionalAccess', _24 => _24.config, 'access', _25 => _25.presentation]), () => ( configPresentation)), () => ( "push")),
+      prefetch: _nullishCoalesce(_optionalChain([page, 'optionalAccess', _26 => _26.config, 'access', _27 => _27.prefetch]), () => ( native.prefetch))
+    };
+    if (_optionalChain([page, 'optionalAccess', _28 => _28.config, 'access', _29 => _29.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 (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;
+      }
+      const blockers = _optionalChain([options, 'access', _30 => _30.analyzerBlockers, 'optionalAccess', _31 => _31.get, 'call', _32 => _32(route)]);
+      warnings.push(
+        `${where}.${tierKey} is "native", but "${route}" has no ${nativeTier === "native" ? "page.native.tsx" : platformFileName} and Farm cannot port pages yet, so it stays web` + (_optionalChain([blockers, 'optionalAccess', _33 => _33.length]) ? `. The analyzer would keep it web: ${blockers.join("; ")}` : "") + ". This fails the build once native screens ship."
+      );
+      screens[route] = { screen: "web", source: "config", requested: nativeTier, ...base };
+      continue;
+    }
+    const file = _nullishCoalesce(reactFile, () => ( platformFile));
+    if (file) {
+      screens[route] = {
+        screen: reactFile ? "native" : "platform",
+        source: "file",
+        file: relativeFile(root, file),
+        module,
+        ...base
+      };
+      continue;
+    }
+    if (native.auto === "on" && _optionalChain([options, 'access', _34 => _34.analyzerPorts, 'optionalAccess', _35 => _35.has, 'call', _36 => _36(route)])) {
+      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 _nullishCoalesce(statement.specifiers, () => ( []))) {
+      const exported = specifier.exported;
+      if ((_nullishCoalesce(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 (_optionalChain([declaration, 'access', _37 => _37.id, 'optionalAccess', _38 => _38.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 (e3) {
+    return segment;
+  }
+}
+function createFarmMobileRoutePattern(pattern, options = {}) {
+  let source = `^${escapeRegex(_chunkD22BUQKWcjs.normalizeFarmBasePath.call(void 0, 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 = _nullishCoalesce(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 = _chunkD22BUQKWcjs.normalizeFarmBasePath.call(void 0, 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) => _chunkYTVSWXEZcjs.compareRoutePatternSpecificity.call(void 0, left, right));
+  const screens = _nullishCoalesce(options.screens, () => ( resolveFarmMobileScreens({ root: "", os: _nullishCoalesce(options.os, () => ( "android")), routes, mobile }).screens));
+  const rules = routes.map((route) => {
+    const decision = _nullishCoalesce(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.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
+  };
+}
+
+// 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"),
+    analyzerCache: path2.join(distDir, "cache", "mobile", "analyzer.json")
+  };
+}
+var SCRIPT_PAGE = /\.(?:tsx|ts|jsx|js)$/;
+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 _promises.readFile.call(void 0, file, "utf8");
+      if (!/\bmobile\b/.test(source)) return;
+      await _asyncNullishCoalesce(parseSync, async () => ( (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(_nullishCoalesce(_nullishCoalesce(_optionalChain([options, 'access', _39 => _39.config, 'optionalAccess', _40 => _40.root]), () => ( options.root)), () => ( process.cwd())));
+  const command = _nullishCoalesce(options.command, () => ( "build"));
+  const mode = command === "dev" ? "development" : "production";
+  const userConfig = options.userConfig === void 0 ? await _chunkLYWAGXXWcjs.loadConfig.call(void 0, root, void 0, mode) : options.userConfig;
+  if (_optionalChain([userConfig, 'optionalAccess', _41 => _41.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 = await _asyncNullishCoalesce(options.config, async () => ( await _chunkLYWAGXXWcjs.resolveConfig.call(void 0, { ...userConfig, root }, mode)));
+  const scan = await _chunk3ATXWZPHcjs.scanRoutePatterns.call(void 0, {
+    root,
+    srcDir: config.srcDir,
+    sourceRoots: _chunk5Y2P454Ocjs.getFarmSourceRoots.call(void 0, config),
+    componentExtensions: _chunkRD623KW4cjs.getFarmRendererComponentExtensions.call(void 0, config.renderer),
+    platformFiles: true
+  });
+  const routes = [...scan.pages].sort();
+  const mobile = resolveFarmMobileConfig(block, { root, srcDir: config.srcDir, routes }, context);
+  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,
+    pageExports
+  };
+  let { screens, warnings } = resolveFarmMobileScreens(screenOptions);
+  let report;
+  let analyzerStats;
+  const analyze = options.analyze === "always" || 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 { analyzeFarmMobileRoutes } = await import("./analyzer-CN7C74WX.cjs");
+    const result = await analyzeFarmMobileRoutes({
+      root,
+      srcDir: config.srcDir,
+      routes: candidates,
+      pageFiles: scan.pageFiles,
+      serverComponents: _chunkBPNOYILCcjs.resolveFarmServerComponentsMode.call(void 0, _optionalChain([config, 'access', _42 => _42.experimental, 'optionalAccess', _43 => _43.serverComponents])) !== void 0,
+      cacheFile: path2.resolve(root, getFarmMobileOutputDirs(config.distDir).analyzerCache)
+    });
+    analyzerStats = result.stats;
+    ({ screens, warnings } = resolveFarmMobileScreens({
+      ...screenOptions,
+      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(
+            (blocker) => `${blocker.file ? `${blocker.file}:${blocker.line}:${blocker.column} ` : ""}${blocker.message}`
+          )
+        ])
+      )
+    }));
+    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
+  });
+  return {
+    context,
+    mobile,
+    manifest,
+    config,
+    screens,
+    warnings,
+    nativeLayouts,
+    pageFiles: scan.pageFiles,
+    ...report ? { report, analyzerStats } : {}
+  };
+}
+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 _promises.mkdir.call(void 0, path2.dirname(file), { recursive: true });
+  await _promises.writeFile.call(void 0, file, `${JSON.stringify(app.manifest, null, 2)}
+`);
+  if (!app.report) return { ...app, file };
+  const reportFile = path2.resolve(app.config.root, dirs.report);
+  await _promises.writeFile.call(void 0, 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 };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.FarmMobileError = FarmMobileError; exports.createFarmMobileContext = createFarmMobileContext; exports.createFarmMobileModuleId = createFarmMobileModuleId; exports.createFarmMobileRouteManifest = createFarmMobileRouteManifest; exports.createFarmMobileRoutePattern = createFarmMobileRoutePattern; exports.formatFarmMobileNativeReport = formatFarmMobileNativeReport; exports.generateFarmMobileRoutes = generateFarmMobileRoutes; exports.getFarmMobileOutputDirs = getFarmMobileOutputDirs; exports.readFarmMobilePageExport = readFarmMobilePageExport; exports.resolveFarmMobileApp = resolveFarmMobileApp; exports.resolveFarmMobileBlock = resolveFarmMobileBlock; exports.resolveFarmMobileConfig = resolveFarmMobileConfig; exports.resolveFarmMobileScreens = resolveFarmMobileScreens; exports.validateFarmMobileConfig = validateFarmMobileConfig;