@farm.js/core 0.1.49 → 0.1.51-beta.0

package/dist/analyzer-VKUDHNDF.cjs

@@ -0,0 +1,1066 @@
+"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(); } } 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 _chunkX5BCMLGPcjs = require('./chunk-X5BCMLGP.cjs');
+require('./chunk-BTZ5O6VM.cjs');
+
+// src/mobile/analyzer.ts
+var _crypto = require('crypto');
+var _fs = require('fs');
+var _promises = require('fs/promises');
+var _path = require('path'); var path = _interopRequireWildcard(_path);
+var ANALYZER_VERSION = `1:${_chunkX5BCMLGPcjs.FARM_VERSION}`;
+var INTRINSIC_KINDS = {};
+for (const tag of "div section main article header footer nav aside figure hr li".split(" ")) {
+  INTRINSIC_KINDS[tag] = "View";
+}
+for (const tag of "p span h1 h2 h3 h4 h5 h6 strong em b i small label code br".split(" ")) {
+  INTRINSIC_KINDS[tag] = "Text";
+}
+Object.assign(INTRINSIC_KINDS, {
+  img: "Image",
+  button: "Pressable",
+  a: "Pressable",
+  input: "TextInput",
+  textarea: "TextInput",
+  ul: "List",
+  ol: "List"
+});
+var INPUT_TYPES = /* @__PURE__ */ new Set(["text", "email", "password", "number", "search", "tel", "url"]);
+var MAPPED_EVENTS = {
+  View: /* @__PURE__ */ new Set(["onClick"]),
+  Text: /* @__PURE__ */ new Set(["onClick"]),
+  Image: /* @__PURE__ */ new Set(["onClick", "onLoad", "onError"]),
+  Pressable: /* @__PURE__ */ new Set(["onClick"]),
+  TextInput: /* @__PURE__ */ new Set(["onChange", "onInput", "onFocus", "onBlur"]),
+  List: /* @__PURE__ */ new Set()
+};
+var BROWSER_GLOBALS = new Set(
+  "window document localStorage sessionStorage navigator matchMedia ResizeObserver IntersectionObserver MutationObserver getComputedStyle requestAnimationFrame cancelAnimationFrame location history indexedDB customElements HTMLElement Element DOMParser screen visualViewport".split(" ")
+);
+var DOM_PACKAGES = [
+  "react-dom",
+  "leaflet",
+  "react-leaflet",
+  "mapbox-gl",
+  "chart.js",
+  "react-chartjs-2",
+  "recharts",
+  "d3",
+  "three",
+  "@react-three/",
+  "framer-motion",
+  "motion",
+  "@radix-ui/",
+  "@headlessui/",
+  "react-markdown",
+  "@tiptap/",
+  "prosemirror-",
+  "@monaco-editor/",
+  "monaco-editor",
+  "codemirror",
+  "@codemirror/",
+  "swiper",
+  "embla-carousel",
+  "lucide-react",
+  "react-icons",
+  "@heroicons/",
+  "shiki",
+  "highlight.js",
+  "prismjs",
+  "styled-components",
+  "@emotion/",
+  "@stylexjs/"
+];
+var PORTABLE_PACKAGES = /* @__PURE__ */ new Set([
+  "react",
+  "@farm.js/ui",
+  "@farm.js/native",
+  "zod",
+  "valibot",
+  "date-fns",
+  "dayjs",
+  "lodash",
+  "lodash-es",
+  "nanoid",
+  "uuid",
+  "clsx",
+  "classnames",
+  "tailwind-merge",
+  "@tanstack/react-query",
+  "zustand",
+  "jotai",
+  "immer"
+]);
+var CORE_PORTABLE = {
+  "@farm.js/core": /* @__PURE__ */ new Set([
+    "Link",
+    "createRoute",
+    "useRouter",
+    "useSearchParams",
+    "usePathname",
+    "navigateTo",
+    "notFound",
+    "redirect",
+    "createServerFn",
+    "createServerQuery"
+  ]),
+  "@farm.js/core/client": /* @__PURE__ */ new Set([
+    "Link",
+    "useRouter",
+    "navigateTo",
+    "createApiClients",
+    "useServerQuery"
+  ]),
+  "@farm.js/core/navigation": /* @__PURE__ */ new Set([
+    "useRouter",
+    "useSearchParams",
+    "usePathname",
+    "notFound",
+    "redirect"
+  ]),
+  "@farm.js/core/server-fn": /* @__PURE__ */ new Set(["createServerFn"]),
+  "@farm.js/core/server-query": /* @__PURE__ */ new Set(["createServerQuery"]),
+  "@farm.js/core/server-fn/client": /* @__PURE__ */ new Set(["useServerFn"]),
+  "@farm.js/core/server-query/client": /* @__PURE__ */ new Set(["useServerQuery", "prefetchServerQuery"]),
+  "@farm.js/core/api/client": /* @__PURE__ */ new Set(["createApiClients"]),
+  "@farm.js/core/image": /* @__PURE__ */ new Set(["Image"]),
+  "@farm.js/core/i18n/client": /* @__PURE__ */ new Set(["useLocale", "useTranslations"]),
+  "@farm.js/core/version": /* @__PURE__ */ new Set(["FARM_VERSION"]),
+  "@farm.js/core/platform": /* @__PURE__ */ new Set(["platform"])
+};
+var MAPPED_COMPONENTS = {
+  "@farm.js/core": { Link: "Pressable" },
+  "@farm.js/core/client": { Link: "Pressable" },
+  "@farm.js/core/image": { Image: "Image" },
+  "@farm.js/ui": {
+    View: "View",
+    Text: "Text",
+    Image: "Image",
+    Pressable: "Pressable",
+    TextInput: "TextInput",
+    List: "List"
+  }
+};
+var SERVER_FN_FACTORIES = /* @__PURE__ */ new Set(["createServerFn", "createServerQuery"]);
+var SCRIPT_EXTENSIONS = [".tsx", ".ts", ".jsx", ".js", ".mjs"];
+var STYLE_FILE = /\.(?:css|scss|sass|less|styl|stylus|pcss|postcss)(?:\?.*)?$/i;
+var ASSET_FILE = /\.(?:png|jpe?g|gif|webp|avif|svg|ico|bmp|json|woff2?|ttf|otf|mp3|wav|txt)(?:\?.*)?$/i;
+var STYLE_PROPERTIES = new Set(
+  "display flexDirection flex flexGrow flexShrink flexBasis flexWrap alignItems alignSelf alignContent justifyContent gap rowGap columnGap padding paddingTop paddingRight paddingBottom paddingLeft paddingInline paddingBlock paddingHorizontal paddingVertical margin marginTop marginRight marginBottom marginLeft marginInline marginBlock width height minWidth minHeight maxWidth maxHeight color backgroundColor borderColor borderWidth borderTopWidth borderRightWidth borderBottomWidth borderLeftWidth borderRadius borderStyle opacity fontSize fontWeight fontStyle fontFamily lineHeight letterSpacing textAlign textDecorationLine textTransform position top right bottom left zIndex overflow aspectRatio".split(" ")
+);
+var STYLE_ENUMS = {
+  display: /* @__PURE__ */ new Set(["flex", "none"]),
+  position: /* @__PURE__ */ new Set(["relative", "absolute"]),
+  overflow: /* @__PURE__ */ new Set(["hidden", "visible"])
+};
+var STYLE_VALUE_BLOCK = /\b(?:calc|var|env|min|max|clamp)\(|\d(?:vh|vw|dvh|svh|lvh|vmin|vmax|em|ch)\b/;
+var COLOR = "(?:inherit|current|transparent|black|white|(?:slate|gray|zinc|neutral|stone|red|orange|amber|yellow|lime|green|emerald|teal|cyan|sky|blue|indigo|violet|purple|fuchsia|pink|rose)-(?:50|[1-9]00|950))(?:/\\d{1,3})?";
+var SPACE = "(?:\\d+(?:\\.5)?|px|auto)";
+var SIZE = "(?:\\d+(?:\\.5)?|px|auto|full|\\d+/\\d+|min|max|fit)";
+var PORTABLE_CLASSES = [
+  /^(?:flex|flex-row|flex-col|flex-row-reverse|flex-col-reverse|flex-wrap|flex-nowrap|flex-wrap-reverse|flex-1|flex-auto|flex-initial|flex-none|grow|grow-0|shrink|shrink-0|hidden|relative|absolute|overflow-hidden|overflow-visible|italic|not-italic|underline|line-through|no-underline|uppercase|lowercase|capitalize|normal-case|text-left|text-center|text-right|text-justify)$/,
+  /^(?:items|justify|self|content)-(?:start|end|center|between|around|evenly|stretch|baseline|auto)$/,
+  new RegExp(
+    `^-?(?:gap|gap-x|gap-y|p|px|py|pt|pr|pb|pl|ps|pe|m|mx|my|mt|mr|mb|ml|ms|me)-${SPACE}$`
+  ),
+  new RegExp(`^(?:w|h|size|min-w|min-h|max-h)-${SIZE}$`),
+  /^max-w-(?:none|xs|sm|md|lg|xl|[2-7]xl|full|min|max|fit)$/,
+  new RegExp(`^-?(?:top|right|bottom|left|inset|inset-x|inset-y)-${SIZE}$`),
+  /^z-(?:\d+|auto)$/,
+  /^text-(?:xs|sm|base|lg|xl|[2-9]xl)$/,
+  /^font-(?:thin|extralight|light|normal|medium|semibold|bold|extrabold|black|sans|serif|mono)$/,
+  /^leading-(?:none|tight|snug|normal|relaxed|loose|\d+)$/,
+  /^tracking-(?:tighter|tight|normal|wide|wider|widest)$/,
+  new RegExp(`^(?:text|bg|border|border-[trblxy])-${COLOR}$`),
+  /^rounded(?:-[trbl]{1,2})?(?:-(?:none|sm|md|lg|xl|2xl|3xl|full))?$/,
+  /^border(?:-[trblxy])?(?:-(?:0|2|4|8))?$/,
+  /^border-(?:solid|dashed|dotted|none)$/,
+  /^opacity-\d{1,3}$/,
+  /^aspect-(?:square|video|auto)$/,
+  // No effect on a touch screen; dropped on native.
+  /^(?:cursor|select|outline|pointer-events)-[a-z-]+$/
+];
+var BLOCKING_CLASSES = [
+  [/^(?:grid|inline-grid|grid-.+|col-.+|row-.+|auto-cols-.+|auto-rows-.+)$/, "uses grid layout"],
+  [/^(?:fixed|sticky)$/, "uses fixed or sticky positioning"],
+  [
+    /^(?:transition.*|duration-.+|ease-.+|delay-.+|animate-.+)$/,
+    "uses CSS transitions or keyframes"
+  ],
+  [/^(?:space-[xy]-.+|divide-.+)$/, "needs child selectors"],
+  [
+    /^(?:block|inline|inline-block|inline-flex|table.*|contents|flow-root|list-item)$/,
+    "sets a display mode other than flex"
+  ],
+  [
+    /^(?:shadow.*|ring.*|blur.*|backdrop-.+|drop-shadow.*|bg-gradient-.+|from-.+|via-.+|to-.+|bg-clip-.+|mix-blend-.+|filter|invert|grayscale.*|sepia.*)$/,
+    "is a visual effect with no native mapping"
+  ],
+  [/^(?:container|prose.*|sr-only|not-sr-only)$/, "needs stylesheet rules"],
+  [
+    /^(?:truncate|line-clamp-.+|whitespace-.+|break-.+|text-ellipsis|text-clip)$/,
+    "needs CSS text wrapping"
+  ]
+];
+function classifyClass(token) {
+  const parts = token.split(":");
+  const utility = parts.pop().replace(/^!/, "");
+  const variant = parts.find((part) => part !== "dark");
+  if (variant) {
+    return /^(?:sm|md|lg|xl|2xl|min-.+|max-.+|portrait|landscape|print)$/.test(variant) ? `"${token}" is a media query` : `"${token}" needs the CSS ${variant}: selector`;
+  }
+  if (utility.includes("[")) return `"${token}" is an arbitrary value`;
+  if (PORTABLE_CLASSES.some((pattern) => pattern.test(utility))) return void 0;
+  for (const [pattern, why] of BLOCKING_CLASSES) {
+    if (pattern.test(utility)) return `"${token}" ${why}`;
+  }
+  return `class "${token}" is not in the native Tailwind subset`;
+}
+function scriptLang(file) {
+  return file.endsWith(".tsx") ? "tsx" : file.endsWith(".ts") ? "ts" : "jsx";
+}
+function lineStarts(source) {
+  const starts = [0];
+  for (let index = source.indexOf("\n"); index !== -1; index = source.indexOf("\n", index + 1)) {
+    starts.push(index + 1);
+  }
+  return starts;
+}
+function locate(starts, offset) {
+  let low = 0;
+  let high = starts.length - 1;
+  while (low < high) {
+    const mid = low + high + 1 >> 1;
+    if (starts[mid] <= offset) low = mid;
+    else high = mid - 1;
+  }
+  return { line: low + 1, column: offset - starts[low] + 1 };
+}
+function collectPatternNames(pattern, names) {
+  if (!pattern) return;
+  switch (pattern.type) {
+    case "Identifier":
+      names.add(pattern.name);
+      return;
+    case "ObjectPattern":
+      for (const property of pattern.properties) {
+        collectPatternNames(
+          property.type === "RestElement" ? property.argument : property.value,
+          names
+        );
+      }
+      return;
+    case "ArrayPattern":
+      for (const element of pattern.elements) collectPatternNames(element, names);
+      return;
+    case "RestElement":
+      collectPatternNames(pattern.argument, names);
+      return;
+    case "AssignmentPattern":
+      collectPatternNames(pattern.left, names);
+      return;
+  }
+}
+function jsxName(name) {
+  if (name.type === "JSXIdentifier") return name.name;
+  if (name.type === "JSXMemberExpression") return `${jsxName(name.object)}.${name.property.name}`;
+  if (name.type === "JSXNamespacedName") return `${name.namespace.name}:${name.name.name}`;
+  return "?";
+}
+function attributeName(attribute) {
+  return attribute.name.type === "JSXNamespacedName" ? `${attribute.name.namespace.name}:${attribute.name.name.name}` : attribute.name.name;
+}
+function staticString(value) {
+  if (!value) return void 0;
+  if (value.type === "Literal" && typeof value.value === "string") return value.value;
+  if (value.type === "JSXExpressionContainer") return staticString(value.expression);
+  if (value.type === "TemplateLiteral" && value.expressions.length === 0) {
+    return value.quasis.map((quasi) => _nullishCoalesce(quasi.value.cooked, () => ( quasi.value.raw))).join("");
+  }
+  return void 0;
+}
+var SKIP_KEYS = /* @__PURE__ */ new Set([
+  "type",
+  "start",
+  "end",
+  "range",
+  "loc",
+  "typeAnnotation",
+  "returnType",
+  "typeParameters",
+  "typeArguments",
+  "decorators"
+]);
+function analyzeSource(file, source, parseSync) {
+  const facts = {
+    imports: [],
+    blockers: [],
+    elements: { total: 0, mapped: 0, byKind: {} },
+    wins: [],
+    useClient: false,
+    serverBoundary: false,
+    asyncDefault: false,
+    components: {}
+  };
+  const starts = lineStarts(source);
+  const block = (node, rule, message) => {
+    facts.blockers.push({ ...locate(starts, node.start), rule, message });
+  };
+  const result = parseSync(file, source, { lang: scriptLang(file) });
+  if (result.errors.length > 0) {
+    const error = result.errors[0];
+    const offset = _nullishCoalesce(_optionalChain([error, 'access', _ => _.labels, 'optionalAccess', _2 => _2[0], 'optionalAccess', _3 => _3.start]), () => ( 0));
+    facts.blockers.push({ ...locate(starts, offset), rule: "parse-error", message: error.message });
+    return facts;
+  }
+  const program = result.program;
+  const wins = /* @__PURE__ */ new Set();
+  const imported = /* @__PURE__ */ new Map();
+  const topLevel = /* @__PURE__ */ new Set();
+  const declared = /* @__PURE__ */ new Set();
+  let callsServerFactory = false;
+  const asyncFunctions = /* @__PURE__ */ new Set();
+  let defaultName;
+  for (const statement of program.body) {
+    if (statement.type === "ExpressionStatement" && statement.directive) {
+      if (statement.directive === "use client") facts.useClient = true;
+      if (statement.directive === "use server") facts.serverBoundary = true;
+      continue;
+    }
+    if (statement.type === "ImportDeclaration") {
+      const where = locate(starts, statement.start);
+      if (statement.importKind === "type") continue;
+      const names = [];
+      for (const specifier of statement.specifiers) {
+        if (specifier.importKind === "type") continue;
+        const name = specifier.type === "ImportDefaultSpecifier" ? "default" : specifier.type === "ImportNamespaceSpecifier" ? "*" : _nullishCoalesce(specifier.imported.name, () => ( specifier.imported.value));
+        names.push(name);
+        imported.set(specifier.local.name, { source: statement.source.value, name });
+        declared.add(specifier.local.name);
+      }
+      if (statement.specifiers.length > 0 && names.length === 0) continue;
+      facts.imports.push({ source: statement.source.value, ...where, names });
+      continue;
+    }
+    if ((statement.type === "ExportNamedDeclaration" || statement.type === "ExportAllDeclaration") && statement.source && statement.exportKind !== "type") {
+      facts.imports.push({
+        source: statement.source.value,
+        ...locate(starts, statement.start),
+        names: statement.type === "ExportAllDeclaration" ? ["*"] : statement.specifiers.filter((specifier) => specifier.exportKind !== "type").map((specifier) => _nullishCoalesce(specifier.local.name, () => ( specifier.local.value)))
+      });
+    }
+    const declaration = statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration" ? statement.declaration : statement;
+    if (!declaration) continue;
+    if (_optionalChain([declaration, 'access', _4 => _4.id, 'optionalAccess', _5 => _5.name]) && /Function|Class/.test(declaration.type)) {
+      topLevel.add(declaration.id.name);
+    }
+    if (_optionalChain([declaration, 'access', _6 => _6.id, 'optionalAccess', _7 => _7.name]) && declaration.async) asyncFunctions.add(declaration.id.name);
+    if (statement.type === "ExportDefaultDeclaration" && declaration.type === "Identifier") {
+      defaultName = declaration.name;
+    }
+    if (declaration.type === "VariableDeclaration") {
+      for (const declarator of declaration.declarations) {
+        if (declarator.id.type !== "Identifier") continue;
+        const init = declarator.init;
+        if (_optionalChain([init, 'optionalAccess', _8 => _8.async])) asyncFunctions.add(declarator.id.name);
+        const callee = _optionalChain([init, 'optionalAccess', _9 => _9.type]) === "CallExpression" ? init.callee : void 0;
+        const calleeName = _optionalChain([callee, 'optionalAccess', _10 => _10.type]) === "MemberExpression" ? callee.property.name : _optionalChain([callee, 'optionalAccess', _11 => _11.name]);
+        if (/Function/.test(_nullishCoalesce(_optionalChain([init, 'optionalAccess', _12 => _12.type]), () => ( ""))) || calleeName && /^(?:memo|forwardRef|lazy)$/.test(calleeName)) {
+          topLevel.add(declarator.id.name);
+        }
+      }
+    }
+    if (statement.type === "ExportDefaultDeclaration" && declaration.async)
+      facts.asyncDefault = true;
+  }
+  const globalCandidates = [];
+  const blockGlobalsLater = () => {
+    for (const node of globalCandidates) {
+      if (!declared.has(node.name)) {
+        block(node, "browser-global", `${node.name} is a browser API`);
+      }
+    }
+  };
+  const classifyElement = (element) => {
+    const opening = element.openingElement;
+    const tag = jsxName(opening.name);
+    let kind;
+    let counted = true;
+    const isIntrinsic = opening.name.type === "JSXIdentifier" && /^[a-z]/.test(tag);
+    if (isIntrinsic) {
+      kind = INTRINSIC_KINDS[tag];
+      if (!kind) block(opening, "unmapped-element", `<${tag}> has no native mapping`);
+    } else if (opening.name.type === "JSXNamespacedName") {
+      block(opening, "unmapped-element", `<${tag}> has no native mapping`);
+    } else {
+      const root = tag.split(".")[0];
+      const binding = imported.get(root);
+      if (binding) {
+        const member = tag.includes(".") ? binding.name === "*" ? tag.split(".")[1] : "" : binding.name;
+        kind = _optionalChain([MAPPED_COMPONENTS, 'access', _13 => _13[binding.source], 'optionalAccess', _14 => _14[member]]);
+        if (!kind) {
+          const fromApp = /^(?:\.|\/|@\/|~|#)/.test(binding.source);
+          counted = !fromApp;
+          kind = fromApp || PORTABLE_PACKAGES.has(packageName(binding.source)) ? "Component" : void 0;
+        }
+      } else if (topLevel.has(root)) {
+        kind = "Component";
+        counted = false;
+      } else {
+        block(
+          opening,
+          "dynamic-component",
+          `<${tag}> is a value the analyzer cannot resolve to a component`
+        );
+      }
+    }
+    if (counted) {
+      facts.elements.total += 1;
+      if (kind) facts.elements.mapped += 1;
+      if (kind && kind !== "Component" && kind !== "Fragment") {
+        facts.elements.byKind[kind] = (_nullishCoalesce(facts.elements.byKind[kind], () => ( 0))) + 1;
+      }
+    }
+    const node = { kind: _nullishCoalesce(kind, () => ( "View")), tag };
+    const props = {};
+    const style = [];
+    const events = [];
+    for (const attribute of opening.attributes) {
+      if (attribute.type === "JSXSpreadAttribute") {
+        if (isIntrinsic)
+          block(attribute, "spread-props", `spread props on <${tag}> cannot be checked`);
+        continue;
+      }
+      const name = attributeName(attribute);
+      const value = attribute.value;
+      if (name === "key") continue;
+      if (name === "dangerouslySetInnerHTML") {
+        block(attribute, "dangerously-set-inner-html", "dangerouslySetInnerHTML");
+        continue;
+      }
+      if (name === "contentEditable") {
+        block(attribute, "content-editable", "contentEditable");
+        continue;
+      }
+      if (name === "ref" && isIntrinsic) {
+        block(attribute, "dom-ref", `a ref on <${tag}> reaches the DOM`);
+        continue;
+      }
+      if ((name === "action" || name === "formAction") && isIntrinsic) {
+        block(attribute, "form-action", `${name} on <${tag}>`);
+        continue;
+      }
+      if (/^on[A-Z]/.test(name)) {
+        if (isIntrinsic && kind && !_optionalChain([MAPPED_EVENTS, 'access', _15 => _15[kind], 'optionalAccess', _16 => _16.has, 'call', _17 => _17(name)])) {
+          block(attribute, "dom-event", `${name} on <${tag}> has no native event`);
+        }
+        events.push(name);
+        continue;
+      }
+      if (name === "className" || name === "class") {
+        const classes = staticString(value);
+        if (classes === void 0) {
+          block(attribute, "runtime-class-name", `<${tag}> builds its class names at runtime`);
+          continue;
+        }
+        for (const token of classes.split(/\s+/).filter(Boolean)) {
+          const problem = classifyClass(token);
+          if (problem) block(attribute, "class-name", problem);
+          else style.push(token);
+        }
+        continue;
+      }
+      if (name === "style") {
+        const expression = _optionalChain([value, 'optionalAccess', _18 => _18.type]) === "JSXExpressionContainer" ? value.expression : null;
+        if (!expression || expression.type !== "ObjectExpression") {
+          block(attribute, "runtime-style", `<${tag}> style is not an object literal`);
+          continue;
+        }
+        for (const property of expression.properties) {
+          if (property.type !== "Property" || property.computed) {
+            block(property, "runtime-style", `<${tag}> style has a spread or computed key`);
+            continue;
+          }
+          const key = _nullishCoalesce(property.key.name, () => ( property.key.value));
+          if (!STYLE_PROPERTIES.has(key)) {
+            block(property, "style", `style.${key} has no native mapping`);
+            continue;
+          }
+          const literal2 = staticString(property.value);
+          if (literal2 !== void 0) {
+            if (STYLE_ENUMS[key] && !STYLE_ENUMS[key].has(literal2)) {
+              block(property, "style", `style.${key} "${literal2}" has no native mapping`);
+              continue;
+            }
+            if (STYLE_VALUE_BLOCK.test(literal2)) {
+              block(
+                property,
+                "style",
+                `style.${key} "${literal2}" uses a CSS-only unit or function`
+              );
+              continue;
+            }
+          } else if (STYLE_ENUMS[key] && property.value.type !== "Literal") {
+            block(property, "style", `style.${key} is computed at runtime`);
+            continue;
+          }
+          style.push(`style.${key}`);
+        }
+        continue;
+      }
+      if (tag === "input" && name === "type") {
+        const type = staticString(value);
+        if (type === void 0 || !INPUT_TYPES.has(type)) {
+          block(
+            attribute,
+            "unmapped-element",
+            `<input type="${_nullishCoalesce(type, () => ( "{expr}"))}"> has no native mapping`
+          );
+        }
+      }
+      const literal = value === null ? true : staticString(value);
+      if (literal !== void 0) props[name] = literal;
+      else if (_optionalChain([value, 'optionalAccess', _19 => _19.type]) === "JSXExpressionContainer" && value.expression.type === "Literal" && (typeof value.expression.value === "number" || typeof value.expression.value === "boolean")) {
+        props[name] = value.expression.value;
+      } else props[name] = "{expr}";
+    }
+    if (kind === "TextInput" && events.some((event) => event === "onChange" || event === "onInput")) {
+      wins.add("input");
+    }
+    if (Object.keys(props).length > 0) node.props = props;
+    if (style.length > 0) node.style = style;
+    if (events.length > 0) node.events = events;
+    return node;
+  };
+  const append = (parent, child) => {
+    if (!parent) return;
+    (_nullishCoalesce(parent.children, () => ( (parent.children = [])))).push(child);
+  };
+  const visit = (node, parent) => {
+    if (!node || typeof node !== "object") return void 0;
+    switch (node.type) {
+      case "ImportDeclaration":
+        return void 0;
+      case "JSXElement": {
+        const ui = classifyElement(node);
+        for (const attribute of node.openingElement.attributes) {
+          visit(attribute.type === "JSXSpreadAttribute" ? attribute.argument : attribute.value);
+        }
+        visitChildren(node.children, ui);
+        append(parent, ui);
+        return ui;
+      }
+      case "JSXFragment": {
+        const ui = { kind: "Fragment", tag: "" };
+        visitChildren(node.children, ui);
+        append(parent, ui);
+        return ui;
+      }
+      case "JSXText": {
+        const text = node.value.replace(/\s+/g, " ").trim();
+        if (text && parent) parent.text = parent.text ? `${parent.text} ${text}` : text;
+        return void 0;
+      }
+      case "JSXExpressionContainer":
+        visit(node.expression, parent);
+        return void 0;
+      case "Identifier":
+        if (BROWSER_GLOBALS.has(node.name)) globalCandidates.push(node);
+        return void 0;
+      case "MemberExpression":
+        visit(node.object, parent);
+        if (node.computed) visit(node.property, parent);
+        return void 0;
+      case "Property":
+      case "PropertyDefinition":
+      case "MethodDefinition":
+        if (node.computed) visit(node.key, parent);
+        visit(node.value, parent);
+        return void 0;
+      case "LabeledStatement":
+        visit(node.body, parent);
+        return void 0;
+      case "BreakStatement":
+      case "ContinueStatement":
+        return void 0;
+      case "VariableDeclarator":
+        collectPatternNames(node.id, declared);
+        visit(node.init, parent);
+        visitPatternDefaults(node.id, parent);
+        return void 0;
+      case "FunctionDeclaration":
+      case "FunctionExpression":
+      case "ArrowFunctionExpression":
+        if (node.id) declared.add(node.id.name);
+        for (const param of node.params) {
+          collectPatternNames(param, declared);
+          visitPatternDefaults(param, parent);
+        }
+        visit(node.body, parent);
+        return void 0;
+      case "ClassDeclaration":
+      case "ClassExpression":
+        if (node.id) declared.add(node.id.name);
+        visit(node.superClass, parent);
+        visit(node.body, parent);
+        return void 0;
+      case "CatchClause":
+        collectPatternNames(node.param, declared);
+        visit(node.body, parent);
+        return void 0;
+      case "CallExpression": {
+        const callee = node.callee;
+        const calleeName = callee.type === "Identifier" ? callee.name : callee.type === "MemberExpression" && !callee.computed ? callee.property.name : void 0;
+        if (calleeName === "useLayoutEffect" || calleeName === "useInsertionEffect") {
+          block(node, "layout-effect", `${calleeName} reads layout from the DOM`);
+        }
+        if (calleeName === "createElement" || calleeName === "cloneElement") {
+          block(
+            node,
+            "create-element",
+            `${calleeName}() builds elements the analyzer cannot check`
+          );
+        }
+        if (calleeName === "setInterval") wins.add("timer");
+        if (callee.type === "Identifier" && SERVER_FN_FACTORIES.has(callee.name)) {
+          const binding = imported.get(callee.name);
+          if (_optionalChain([binding, 'optionalAccess', _20 => _20.source, 'access', _21 => _21.startsWith, 'call', _22 => _22("@farm.js/core")])) callsServerFactory = true;
+        }
+        if (calleeName === "map" && callee.type === "MemberExpression" && parent) {
+          const before = facts.elements.total;
+          visit(callee.object, parent);
+          for (const argument of node.arguments) visit(argument, parent);
+          if (facts.elements.total > before) wins.add("list");
+          return void 0;
+        }
+        visit(callee, parent);
+        for (const argument of node.arguments) visit(argument, parent);
+        return void 0;
+      }
+      case "ImportExpression": {
+        const specifier = staticString(node.source);
+        facts.imports.push({
+          source: _nullishCoalesce(specifier, () => ( "")),
+          ...locate(starts, node.start),
+          names: ["*"],
+          dynamic: true,
+          ...specifier === void 0 ? { computed: true } : {}
+        });
+        if (specifier === void 0) visit(node.source, parent);
+        return void 0;
+      }
+    }
+    if (node.type.startsWith("TS")) {
+      if (node.expression) visit(node.expression, parent);
+      return void 0;
+    }
+    for (const key in node) {
+      if (SKIP_KEYS.has(key)) continue;
+      const value = node[key];
+      if (Array.isArray(value)) {
+        for (const item of value) if (item && typeof item.type === "string") visit(item, parent);
+      } else if (value && typeof value.type === "string") {
+        visit(value, parent);
+      }
+    }
+    return void 0;
+  };
+  const visitChildren = (children, parent) => {
+    _nullishCoalesce(parent.children, () => ( (parent.children = [])));
+    for (const child of children) visit(child, parent);
+    if (parent.children.length === 0) delete parent.children;
+  };
+  const visitPatternDefaults = (pattern, parent) => {
+    if (!pattern) return;
+    if (pattern.type === "AssignmentPattern") visit(pattern.right, parent);
+    else if (pattern.type === "ObjectPattern") {
+      for (const property of pattern.properties) {
+        visitPatternDefaults(
+          property.type === "RestElement" ? property.argument : property.value,
+          parent
+        );
+      }
+    } else if (pattern.type === "ArrayPattern") {
+      for (const element of pattern.elements) visitPatternDefaults(element, parent);
+    }
+  };
+  for (const statement of program.body) {
+    if (statement.type === "ImportDeclaration") continue;
+    const isDefault = statement.type === "ExportDefaultDeclaration";
+    const declaration = statement.type === "ExportNamedDeclaration" || isDefault ? statement.declaration : statement;
+    const roots = [];
+    if (_optionalChain([declaration, 'optionalAccess', _23 => _23.type]) === "FunctionDeclaration" || isDefault && /Function/.test(_nullishCoalesce(_optionalChain([declaration, 'optionalAccess', _24 => _24.type]), () => ( "")))) {
+      roots.push([isDefault ? "default" : declaration.id.name, declaration]);
+    } else if (_optionalChain([declaration, 'optionalAccess', _25 => _25.type]) === "VariableDeclaration") {
+      for (const declarator of declaration.declarations) {
+        if (declarator.id.type === "Identifier" && /Function/.test(_nullishCoalesce(_optionalChain([declarator, 'access', _26 => _26.init, 'optionalAccess', _27 => _27.type]), () => ( "")))) {
+          roots.push([declarator.id.name, declarator]);
+        }
+      }
+    }
+    if (roots.length === 0) {
+      visit(statement);
+      continue;
+    }
+    for (const [name, root] of roots) {
+      const holder = { kind: "Fragment", tag: name, children: [] };
+      visit(root, holder);
+      if (holder.children.length > 0) {
+        facts.components[name] = holder.children.length === 1 ? holder.children[0] : holder;
+      }
+    }
+    if (isDefault && _optionalChain([declaration, 'optionalAccess', _28 => _28.type]) === "Identifier") {
+      facts.components.default = { kind: "Component", tag: declaration.name };
+    }
+  }
+  blockGlobalsLater();
+  if (defaultName && asyncFunctions.has(defaultName)) facts.asyncDefault = true;
+  if (callsServerFactory) facts.serverBoundary = true;
+  facts.wins = [...wins].sort();
+  facts.blockers.sort((left, right) => left.line - right.line || left.column - right.column);
+  return facts;
+}
+function readAliases(root, srcDir) {
+  const aliases = [{ prefix: "@/", targets: [path.join(root, srcDir) + path.sep] }];
+  try {
+    const raw = _fs.readFileSync.call(void 0, path.join(root, "tsconfig.json"), "utf8").replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:"'])\/\/.*$/gm, "$1").replace(/,(\s*[}\]])/g, "$1");
+    const options = _nullishCoalesce(JSON.parse(raw).compilerOptions, () => ( {}));
+    const base = path.resolve(root, _nullishCoalesce(options.baseUrl, () => ( ".")));
+    for (const [key, values] of Object.entries(_nullishCoalesce(options.paths, () => ( {})))) {
+      const prefix = key.replace(/\*$/, "");
+      aliases.push({
+        prefix,
+        targets: values.map((value) => path.join(base, value.replace(/\*$/, "")))
+      });
+    }
+  } catch (e) {
+  }
+  return aliases.sort((left, right) => right.prefix.length - left.prefix.length);
+}
+function isFile(file) {
+  try {
+    return _fs.statSync.call(void 0, file).isFile();
+  } catch (e2) {
+    return false;
+  }
+}
+function resolveFile(base) {
+  if (isFile(base)) return base;
+  for (const extension of SCRIPT_EXTENSIONS) if (isFile(base + extension)) return base + extension;
+  const withoutJs = base.replace(/\.(?:js|jsx|mjs)$/, "");
+  if (withoutJs !== base) {
+    for (const extension of [".ts", ".tsx"])
+      if (isFile(withoutJs + extension)) return withoutJs + extension;
+  }
+  for (const extension of SCRIPT_EXTENSIONS) {
+    const index = path.join(base, `index${extension}`);
+    if (isFile(index)) return index;
+  }
+  return void 0;
+}
+function packageName(specifier) {
+  const parts = specifier.split("/");
+  return specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+}
+function classifyPackage(fact, serverBoundary) {
+  const at = { line: fact.line, column: fact.column };
+  const specifier = fact.source;
+  if (specifier.startsWith("node:") || NODE_BUILTINS.has(packageName(specifier))) {
+    return serverBoundary ? void 0 : { ...at, rule: "node-builtin", message: `import "${specifier}" is a Node.js API` };
+  }
+  if (specifier.startsWith("@farm.js/core")) {
+    const portable = CORE_PORTABLE[specifier];
+    const unmapped = fact.names.filter((name2) => !_optionalChain([portable, 'optionalAccess', _29 => _29.has, 'call', _30 => _30(name2)]));
+    if (unmapped.length > 0 || !portable) {
+      return {
+        ...at,
+        rule: "unmapped-import",
+        message: `${unmapped.join(", ") || "import"} from "${specifier}" has no native mapping`
+      };
+    }
+    return void 0;
+  }
+  const name = packageName(specifier);
+  if (name === "react") {
+    return specifier === "react" || specifier === "react/jsx-runtime" || specifier === "react/jsx-dev-runtime" ? void 0 : { ...at, rule: "unknown-package", message: `import "${specifier}" has no native mapping` };
+  }
+  if (PORTABLE_PACKAGES.has(name)) return void 0;
+  if (DOM_PACKAGES.some(
+    (entry) => entry.endsWith("/") || entry.endsWith("-") ? specifier.startsWith(entry) : name === entry
+  )) {
+    return { ...at, rule: "dom-package", message: `import "${specifier}" renders to the DOM` };
+  }
+  return {
+    ...at,
+    rule: "unknown-package",
+    message: `import "${specifier}" has no native mapping`
+  };
+}
+var NODE_BUILTINS = new Set(
+  "assert buffer child_process cluster crypto dgram dns events fs http http2 https module net os path perf_hooks process querystring readline stream string_decoder timers tls tty url util v8 vm worker_threads zlib".split(" ")
+);
+function relative2(root, file) {
+  return path.relative(root, file).split(path.sep).join("/");
+}
+var LAYOUT_EXTENSIONS = [".tsx", ".ts", ".jsx", ".js"];
+function layoutChain(appDir, pageFile, layoutByDir) {
+  const layouts = [];
+  let dir = path.dirname(pageFile);
+  for (; ; ) {
+    let layout = layoutByDir.get(dir);
+    if (layout === void 0) {
+      const replaced = LAYOUT_EXTENSIONS.some(
+        (extension) => _fs.existsSync.call(void 0, path.join(dir, `layout.native${extension}`))
+      );
+      layout = replaced ? null : _nullishCoalesce(LAYOUT_EXTENSIONS.map((extension) => path.join(dir, `layout${extension}`)).find(
+        (file) => _fs.existsSync.call(void 0, file)
+      ), () => ( null));
+      layoutByDir.set(dir, layout);
+    }
+    if (layout) layouts.unshift(layout);
+    if (path.resolve(dir) === path.resolve(appDir) || path.dirname(dir) === dir) break;
+    dir = path.dirname(dir);
+  }
+  return layouts;
+}
+async function analyzeFarmMobileRoutes(options) {
+  const started = performance.now();
+  const root = path.resolve(options.root);
+  const srcDir = options.srcDir || "src";
+  const aliases = readAliases(root, srcDir);
+  const { parseSync } = await import("rolldown/utils");
+  let cache = { version: ANALYZER_VERSION, modules: {} };
+  if (options.cacheFile) {
+    try {
+      const stored = JSON.parse(await _promises.readFile.call(void 0, options.cacheFile, "utf8"));
+      if (stored.version === ANALYZER_VERSION && stored.modules) cache = stored;
+    } catch (e3) {
+    }
+  }
+  const used = {};
+  let parsed = 0;
+  let cached = 0;
+  const facts = /* @__PURE__ */ new Map();
+  const resolved = /* @__PURE__ */ new Map();
+  const loadFacts = (file) => {
+    let pending = facts.get(file);
+    if (!pending) {
+      pending = _promises.readFile.call(void 0, file, "utf8").then((source) => {
+        const hash = _crypto.createHash.call(void 0, "sha1").update(file.endsWith(".tsx") ? "tsx\0" : file.endsWith(".ts") ? "ts\0" : "jsx\0").update(source).digest("hex");
+        let result = cache.modules[hash];
+        if (result) cached += 1;
+        else {
+          result = analyzeSource(file, source, parseSync);
+          parsed += 1;
+        }
+        used[hash] = result;
+        return result;
+      });
+      facts.set(file, pending);
+    }
+    return pending;
+  };
+  const resolveImport = (from, fact, moduleFacts) => {
+    const at = { line: fact.line, column: fact.column };
+    if (fact.computed) {
+      return {
+        fact,
+        blocker: {
+          ...at,
+          rule: "dynamic-import",
+          message: "import() of a computed specifier cannot be followed"
+        }
+      };
+    }
+    const specifier = fact.source;
+    let candidates;
+    if (specifier.startsWith(".") || specifier.startsWith("/")) {
+      candidates = [
+        specifier.startsWith("/") ? path.join(root, specifier) : path.resolve(path.dirname(from), specifier)
+      ];
+    } else {
+      const alias = aliases.find(
+        (entry) => specifier.startsWith(entry.prefix) || specifier === entry.prefix.replace(/\/$/, "")
+      );
+      if (alias) {
+        candidates = alias.targets.map(
+          (target) => path.join(target, specifier.slice(alias.prefix.length))
+        );
+      }
+    }
+    if (!candidates) {
+      if (STYLE_FILE.test(specifier)) {
+        return {
+          fact,
+          blocker: { ...at, rule: "css-import", message: `import "${specifier}" is a stylesheet` }
+        };
+      }
+      const blocker = classifyPackage(fact, moduleFacts.serverBoundary);
+      return blocker ? { fact, blocker } : { fact };
+    }
+    if (STYLE_FILE.test(specifier)) {
+      return {
+        fact,
+        blocker: { ...at, rule: "css-import", message: `import "${specifier}" is a stylesheet` }
+      };
+    }
+    if (ASSET_FILE.test(specifier)) return { fact };
+    for (const candidate of candidates) {
+      const file = resolveFile(candidate);
+      if (file) {
+        if (ASSET_FILE.test(file)) return { fact };
+        if (STYLE_FILE.test(file)) {
+          return {
+            fact,
+            blocker: {
+              ...at,
+              rule: "css-import",
+              message: `import "${specifier}" is a stylesheet`
+            }
+          };
+        }
+        if (!SCRIPT_EXTENSIONS.some((extension) => file.endsWith(extension))) {
+          return {
+            fact,
+            blocker: {
+              ...at,
+              rule: "unresolved-import",
+              message: `import "${specifier}" is not a script module`
+            }
+          };
+        }
+        return { fact, file };
+      }
+    }
+    return {
+      fact,
+      blocker: { ...at, rule: "unresolved-import", message: `import "${specifier}" was not found` }
+    };
+  };
+  const visitModule = async (file) => {
+    if (resolved.has(file)) return;
+    resolved.set(file, []);
+    const moduleFacts = await loadFacts(file);
+    const imports = moduleFacts.imports.map((fact) => resolveImport(file, fact, moduleFacts));
+    resolved.set(file, imports);
+    if (moduleFacts.serverBoundary) return;
+    await Promise.all(imports.map((entry) => entry.file ? visitModule(entry.file) : void 0));
+  };
+  const appDir = path.join(root, srcDir, "app");
+  const entries = /* @__PURE__ */ new Map();
+  const layoutByDir = /* @__PURE__ */ new Map();
+  for (const route of options.routes) {
+    const page = options.pageFiles.get(route);
+    entries.set(route, { page, layouts: page ? layoutChain(appDir, page, layoutByDir) : [] });
+  }
+  const scripts = /* @__PURE__ */ new Set();
+  for (const { page, layouts } of entries.values()) {
+    for (const file of [page, ...layouts]) {
+      if (file && SCRIPT_EXTENSIONS.some((extension) => file.endsWith(extension)))
+        scripts.add(file);
+    }
+  }
+  await Promise.all([...scripts].map(visitModule));
+  const settled = /* @__PURE__ */ new Map();
+  for (const [file, pending] of facts) settled.set(file, await pending);
+  const routes = {};
+  for (const [route, { page, layouts }] of entries) {
+    const blockers = [];
+    const wins = /* @__PURE__ */ new Set();
+    const elements = { total: 0, mapped: 0, byKind: {} };
+    const seen = /* @__PURE__ */ new Set();
+    const ir = { root: "", components: {} };
+    const walk = (file, entry) => {
+      if (seen.has(file)) return;
+      seen.add(file);
+      const moduleFacts = settled.get(file);
+      const label = relative2(root, file);
+      if (entry && options.serverComponents && !moduleFacts.useClient) {
+        blockers.push({
+          file: label,
+          line: 1,
+          column: 1,
+          rule: "server-component",
+          message: 'a server component (no "use client") renders on the server'
+        });
+      }
+      if (entry && moduleFacts.asyncDefault) {
+        blockers.push({
+          file: label,
+          line: 1,
+          column: 1,
+          rule: "async-component",
+          message: "an async component renders on the server"
+        });
+      }
+      if (moduleFacts.serverBoundary && !entry) return;
+      for (const blocker of moduleFacts.blockers) blockers.push({ file: label, ...blocker });
+      for (const win of moduleFacts.wins) wins.add(win);
+      elements.total += moduleFacts.elements.total;
+      elements.mapped += moduleFacts.elements.mapped;
+      for (const [kind, count] of Object.entries(moduleFacts.elements.byKind)) {
+        elements.byKind[kind] = (_nullishCoalesce(elements.byKind[kind], () => ( 0))) + count;
+      }
+      for (const [name, node] of Object.entries(moduleFacts.components)) {
+        ir.components[`${label}#${name}`] = node;
+      }
+      for (const entryImport of _nullishCoalesce(resolved.get(file), () => ( []))) {
+        if (entryImport.blocker) blockers.push({ file: label, ...entryImport.blocker });
+        if (entryImport.file) walk(entryImport.file, false);
+      }
+    };
+    if (!page) {
+      blockers.push({
+        file: "",
+        line: 0,
+        column: 0,
+        rule: "programmatic-route",
+        message: "a programmatic route has no page file to analyze"
+      });
+    } else if (/\.(?:md|mdx)$/.test(page)) {
+      blockers.push({
+        file: relative2(root, page),
+        line: 1,
+        column: 1,
+        rule: "markdown-page",
+        message: "a Markdown page renders HTML from Markdown"
+      });
+    } else {
+      walk(page, true);
+      ir.root = `${relative2(root, page)}#default`;
+    }
+    for (const layout of layouts) walk(layout, true);
+    const portable = blockers.length === 0;
+    const sortedWins = [...wins].sort();
+    const analysis = {
+      route,
+      decision: portable && sortedWins.length > 0 ? "port" : "web",
+      portable,
+      blockers,
+      wins: sortedWins,
+      elements,
+      portablePercent: elements.total === 0 ? portable ? 100 : 0 : Math.round(elements.mapped / elements.total * 100),
+      modules: seen.size
+    };
+    if (portable) {
+      analysis.ir = ir;
+      analysis.irBytes = Buffer.byteLength(JSON.stringify(ir));
+    }
+    routes[route] = analysis;
+  }
+  if (options.cacheFile) {
+    await _promises.mkdir.call(void 0, path.dirname(options.cacheFile), { recursive: true });
+    await _promises.writeFile.call(void 0, 
+      options.cacheFile,
+      JSON.stringify({ version: ANALYZER_VERSION, modules: used })
+    );
+  }
+  return {
+    routes,
+    stats: { modules: facts.size, parsed, cached, ms: Math.round(performance.now() - started) }
+  };
+}
+
+
+
+exports.CORE_PORTABLE = CORE_PORTABLE; exports.analyzeFarmMobileRoutes = analyzeFarmMobileRoutes;