@farm.js/core 0.1.61 → 0.1.62

package/dist/port-VTLHPZOI.cjs

@@ -0,0 +1,419 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } 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 _chunkV727H3RIcjs = require('./chunk-V727H3RI.cjs');
+require('./chunk-BTZ5O6VM.cjs');
+
+// src/mobile/port.ts
+var _fs = require('fs');
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var DOM_TAGS = new Set(
+  "div section main article header footer nav aside figure hr p h1 h2 h3 h4 h5 h6 span strong em b i small code label br a button input textarea img ul ol li".split(" ")
+);
+var DOM_PROPS = new Set(
+  "key style href src alt width height value defaultValue placeholder type disabled readOnly autoFocus maxLength rows name id title role htmlFor target rel tabIndex lang dir onClick onChange onInput onFocus onBlur onLoad onError".split(" ")
+);
+var REACT_NAMES = new Set(
+  "default Fragment StrictMode memo forwardRef useState useReducer useMemo useCallback useEffect useRef useId useTransition useDeferredValue startTransition".split(" ")
+);
+var PURE_PACKAGES = /* @__PURE__ */ new Set([
+  "zod",
+  "valibot",
+  "date-fns",
+  "dayjs",
+  "lodash",
+  "lodash-es",
+  "nanoid",
+  "uuid",
+  "clsx",
+  "classnames",
+  "tailwind-merge",
+  "zustand",
+  "jotai",
+  "immer"
+]);
+var CORE_LINK = /* @__PURE__ */ new Set(["@farm.js/core", "@farm.js/core/client"]);
+var SCRIPT = /\.(?:tsx|ts|jsx|js|mjs)$/;
+function packageName(specifier) {
+  const parts = specifier.split("/");
+  return specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+}
+function posix(file) {
+  return file.split(_path2.default.sep).join("/");
+}
+function withoutExtension(file) {
+  return file.replace(SCRIPT, "");
+}
+function specifierBetween(fromFile, toFile) {
+  const relative = posix(_path2.default.relative(_path2.default.dirname(fromFile), withoutExtension(toFile)));
+  return relative.startsWith(".") ? relative : `./${relative}`;
+}
+function walk(node, visit) {
+  if (Array.isArray(node)) {
+    for (const child of node) walk(child, visit);
+    return;
+  }
+  if (!node || typeof node !== "object") return;
+  const current = node;
+  if (typeof current.type === "string") visit(current);
+  for (const [key, value] of Object.entries(current)) {
+    if (key !== "type" && key !== "start" && key !== "end" && value && typeof value === "object") {
+      walk(value, visit);
+    }
+  }
+}
+function hasJsx(program) {
+  let found = false;
+  walk(program, (node) => {
+    if (node.type === "JSXElement" || node.type === "JSXFragment") found = true;
+  });
+  return found;
+}
+function staticString(value) {
+  if (!value) return void 0;
+  if ((value.type === "Literal" || value.type === "StringLiteral") && 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) => quasi.value.cooked).join("");
+  }
+  return void 0;
+}
+function lineColumn(source, offset) {
+  const before = source.slice(0, offset).split("\n");
+  return `${before.length}:${before.at(-1).length + 1}`;
+}
+async function emitFarmMobilePort(options) {
+  const { root, graph, portsDir } = options;
+  const read = _nullishCoalesce(options.readFile, () => ( ((file) => _fs.readFileSync.call(void 0, file, "utf8"))));
+  const { parseSync } = await import("rolldown/utils");
+  const problems = [];
+  const copyOf = (file) => _path2.default.join(portsDir, _path2.default.relative(root, file));
+  const parsed = /* @__PURE__ */ new Map();
+  for (const module of graph.modules) {
+    const source = read(module.file);
+    const lang = module.file.endsWith(".tsx") ? "tsx" : module.file.endsWith(".ts") ? "ts" : "jsx";
+    parsed.set(module.file, { source, program: parseSync(module.file, source, { lang }).program });
+  }
+  const copied = new Set(
+    graph.modules.filter((module) => module.file === graph.page || hasJsx(parsed.get(module.file).program)).map((module) => module.file)
+  );
+  const files = {};
+  const tags = /* @__PURE__ */ new Set();
+  const classNames = [];
+  const outputs = [];
+  for (const module of graph.modules) {
+    const label = posix(_path2.default.relative(root, module.file));
+    if (module.serverBoundary) {
+      problems.push(`${label} defines server functions, which ports do not call yet`);
+      continue;
+    }
+    if (!copied.has(module.file)) continue;
+    const { source, program } = parsed.get(module.file);
+    const at = (node) => `${label}:${lineColumn(source, node.start)}`;
+    const edits = [];
+    const resolvedBySource = new Map(module.imports.map((entry2) => [entry2.source, entry2.file]));
+    const linkNames = /* @__PURE__ */ new Set();
+    const reactObjects = /* @__PURE__ */ new Set();
+    let usesDom = false;
+    const rewriteSource = (node, kind) => {
+      const specifier = node.value;
+      const target = resolvedBySource.get(specifier);
+      if (target) {
+        if (kind === "value" && !SCRIPT.test(target)) {
+          problems.push(`${at(node)} imports "${specifier}", an asset ports do not load yet`);
+          return;
+        }
+        const next = specifierBetween(
+          copyOf(module.file),
+          copied.has(target) ? copyOf(target) : target
+        );
+        edits.push({ start: node.start, end: node.end, text: JSON.stringify(next) });
+        return;
+      }
+      if (specifier.startsWith(".") || specifier.startsWith("/")) {
+        if (kind === "value") {
+          problems.push(`${at(node)} imports "${specifier}", an asset ports do not load yet`);
+        }
+        return;
+      }
+      if (kind === "type" || specifier === "react" || specifier === "@farm.js/ui" || PURE_PACKAGES.has(packageName(specifier))) {
+        return;
+      }
+      if (!CORE_LINK.has(specifier)) {
+        problems.push(`${at(node)} imports "${specifier}", which ports do not map yet`);
+      }
+    };
+    for (const statement of program.body) {
+      if (statement.type === "ImportDeclaration") {
+        const typeOnly = statement.importKind === "type";
+        const specifier = statement.source.value;
+        if (!typeOnly && specifier === "react") {
+          for (const imported of statement.specifiers) {
+            if (imported.importKind === "type") continue;
+            if (imported.type !== "ImportSpecifier") reactObjects.add(imported.local.name);
+            const name = imported.type === "ImportSpecifier" ? _nullishCoalesce(imported.imported.name, () => ( imported.imported.value)) : "default";
+            if (!REACT_NAMES.has(name)) {
+              problems.push(
+                `${at(imported)} uses ${name} from "react", which ports do not support yet`
+              );
+            }
+          }
+        }
+        if (/\.css$/i.test(specifier)) {
+          if (statement.specifiers.length > 0) {
+            problems.push(`${at(statement)} imports CSS module names, which ports do not map yet`);
+          } else edits.push({ start: statement.start, end: statement.end, text: "" });
+          continue;
+        }
+        if (!typeOnly && CORE_LINK.has(specifier)) {
+          const values = statement.specifiers.filter(
+            (imported) => imported.importKind !== "type"
+          );
+          for (const imported of values) {
+            const name = imported.type === "ImportSpecifier" ? imported.imported.name : "default";
+            if (name === "Link") linkNames.add(imported.local.name);
+            else
+              problems.push(
+                `${at(imported)} uses ${name} from "${specifier}", which ports do not map yet`
+              );
+          }
+          const types = statement.specifiers.filter(
+            (imported) => imported.importKind === "type"
+          );
+          edits.push({
+            start: statement.start,
+            end: statement.end,
+            text: types.length === 0 ? "" : `import type { ${types.map(
+              (imported) => source.slice(imported.start, imported.end).replace(/^type\s+/, "")
+            ).join(", ")} } from ${JSON.stringify(specifier)};`
+          });
+          continue;
+        }
+        rewriteSource(statement.source, typeOnly ? "type" : "value");
+      } else if ((statement.type === "ExportNamedDeclaration" || statement.type === "ExportAllDeclaration") && statement.source) {
+        rewriteSource(statement.source, statement.exportKind === "type" ? "type" : "value");
+      }
+    }
+    walk(program, (node) => {
+      if (node.type === "MemberExpression" && _optionalChain([node, 'access', _ => _.object, 'optionalAccess', _2 => _2.type]) === "Identifier" && reactObjects.has(node.object.name) && _optionalChain([node, 'access', _3 => _3.property, 'optionalAccess', _4 => _4.type]) === "Identifier" && !REACT_NAMES.has(node.property.name)) {
+        problems.push(
+          `${at(node)} uses ${node.property.name} from "react", which ports do not support yet`
+        );
+      }
+      if (node.type === "ImportExpression") {
+        problems.push(`${at(node)} imports a module at runtime, which ports do not follow yet`);
+      }
+      if (node.type === "JSXOpeningElement" || node.type === "JSXClosingElement") {
+        const name = node.name;
+        if (name.type !== "JSXIdentifier") return;
+        const className = (tag) => {
+          if (node.type !== "JSXOpeningElement") return;
+          for (const attribute of node.attributes) {
+            if (attribute.type !== "JSXAttribute" || attribute.name.name !== "className") continue;
+            const classes = staticString(attribute.value);
+            if (classes === void 0) {
+              problems.push(`${at(attribute)} <${tag}> builds its class names at runtime`);
+              continue;
+            }
+            classNames.push({
+              edits,
+              attribute,
+              tag,
+              classes: classes.split(/\s+/).filter(Boolean),
+              at: at(attribute)
+            });
+          }
+        };
+        if (linkNames.has(name.name)) {
+          edits.push({ start: name.start, end: name.end, text: "__FarmLink" });
+          tags.add("a");
+          className("a");
+          return;
+        }
+        if (!/^[a-z]/.test(name.name)) return;
+        if (!DOM_TAGS.has(name.name)) {
+          if (node.type === "JSXOpeningElement") {
+            problems.push(`${at(node)} renders <${name.name}>, which ports do not draw yet`);
+          }
+          return;
+        }
+        usesDom = true;
+        tags.add(name.name);
+        edits.push({ start: name.start, end: name.end, text: `__FarmDom.${name.name}` });
+        if (node.type !== "JSXOpeningElement") return;
+        for (const attribute of node.attributes) {
+          if (attribute.type === "JSXSpreadAttribute") {
+            problems.push(`${at(attribute)} spreads props on <${name.name}>`);
+            continue;
+          }
+          const prop = attribute.name.type === "JSXNamespacedName" ? `${attribute.name.namespace.name}:${attribute.name.name.name}` : attribute.name.name;
+          if (prop !== "className" && !DOM_PROPS.has(prop) && !/^(?:aria|data)-/.test(prop)) {
+            problems.push(`${at(attribute)} <${name.name} ${prop}> has no port mapping yet`);
+          }
+        }
+        className(name.name);
+      }
+    });
+    if (linkNames.size > 0 || usesDom) {
+      const names = [
+        ...usesDom ? ["FarmDom as __FarmDom"] : [],
+        ...linkNames.size > 0 ? ["Link as __FarmLink"] : []
+      ];
+      const body = program.body;
+      const first = body.find(
+        (statement) => !(statement.type === "ExpressionStatement" && statement.directive)
+      );
+      edits.push({
+        start: _nullishCoalesce(_optionalChain([first, 'optionalAccess', _5 => _5.start]), () => ( source.length)),
+        end: _nullishCoalesce(_optionalChain([first, 'optionalAccess', _6 => _6.start]), () => ( source.length)),
+        text: `import { ${names.join(", ")} } from "@farm.js/native/elements";
+`
+      });
+    }
+    outputs.push({
+      key: posix(_path2.default.relative(portsDir, copyOf(module.file))),
+      label,
+      source,
+      edits
+    });
+  }
+  const page = parsed.get(graph.page);
+  const hasDefault = page.program.body.some(
+    (statement) => statement.type === "ExportDefaultDeclaration"
+  );
+  if (!hasDefault) problems.push(`${posix(_path2.default.relative(root, graph.page))} has no default export`);
+  const sheets = [];
+  const themeDeclarations = [];
+  let tailwind = false;
+  for (const file of _nullishCoalesce(options.stylesheets, () => ( []))) {
+    let css = read(file).replace(/\/\*[\s\S]*?\*\//g, "");
+    css = css.replace(/@import\s+(["'])tailwindcss\1[^;]*;/g, () => {
+      tailwind = true;
+      return "";
+    });
+    css = css.replace(/@source\b[^;]*;/g, "");
+    css = css.replace(/@theme\b[^{;]*\{([^{}]*)\}/g, (_block, body) => {
+      for (const match of body.matchAll(/(--[\w*-]+)\s*:\s*([^;]+);?/g)) {
+        themeDeclarations.push([match[1], match[2].trim()]);
+      }
+      return "";
+    });
+    const directive = /@(?:import|layer|tailwind|apply|theme|utility|plugin|config|custom-variant|variant|reference)\b/.exec(
+      css
+    );
+    if (directive) {
+      problems.push(
+        `${posix(_path2.default.relative(root, file))} uses ${directive[0]}, which ports do not read yet`
+      );
+    } else sheets.push(_chunkV727H3RIcjs.parseFarmNativeStylesheet.call(void 0, css));
+  }
+  for (const specifier of _nullishCoalesce(options.unreadStylesheets, () => ( []))) {
+    problems.push(`the app imports "${specifier}", which ports cannot read as plain CSS`);
+  }
+  const sheet = {};
+  const rootVars = {
+    light: Object.assign(
+      {},
+      ...sheets.map((sheet2) => sheet2.vars.light),
+      Object.fromEntries(themeDeclarations)
+    ),
+    dark: Object.assign({}, ...sheets.map((sheet2) => sheet2.vars.dark))
+  };
+  const theme = themeDeclarations.length > 0 ? _chunkV727H3RIcjs.createFarmNativeTheme.call(void 0, themeDeclarations, rootVars) : void 0;
+  const contextClasses = /* @__PURE__ */ new Set([
+    ...graph.layoutClasses,
+    ...classNames.flatMap((entry2) => entry2.classes)
+  ]);
+  for (const { edits, attribute, tag, classes, at } of classNames) {
+    const utilities = [];
+    const appClasses = [];
+    for (const token of classes) {
+      const inTable = _chunkV727H3RIcjs.resolveFarmNativeClasses.call(void 0, token, theme).unsupported.length === 0;
+      const styled = _chunkV727H3RIcjs.inspectFarmNativeStylesheets.call(void 0, sheets, { class: token }).styled;
+      if (tailwind && inTable) utilities.push(token);
+      if (styled) appClasses.push(token);
+      else if (tailwind && !inTable) {
+        problems.push(
+          `${at} ${_nullishCoalesce(_chunkV727H3RIcjs.farmNativeClassProblem.call(void 0, token, theme), () => ( `class "${token}" has no port style`))}`
+        );
+      }
+    }
+    const tw = _chunkV727H3RIcjs.resolveFarmNativeClasses.call(void 0, utilities.join(" "), theme);
+    const css = _chunkV727H3RIcjs.cascadeFarmNativeStylesheetsForElement.call(void 0, 
+      sheets,
+      { tag, classes: appClasses },
+      contextClasses
+    );
+    problems.push(...css.problems.map((message) => `${at} ${message}`));
+    const resolved = {
+      ...utilities.length > 0 ? { tw: { style: tw.style, ...tw.dark ? { dark: tw.dark } : {} } } : {},
+      css: {
+        style: css.style,
+        ...Object.keys(css.dark).length > 0 ? { dark: css.dark } : {},
+        ...css.inherit.length > 0 ? { inherit: css.inherit } : {}
+      }
+    };
+    edits.push({
+      start: attribute.start,
+      end: attribute.end,
+      text: `__farm={${JSON.stringify(resolved)}}`
+    });
+  }
+  for (const { key, label, source, edits } of outputs) {
+    let output = source;
+    for (const edit of edits.sort(
+      (left, right) => right.start - left.start || right.end - left.end
+    )) {
+      output = output.slice(0, edit.start) + edit.text + output.slice(edit.end);
+    }
+    files[key] = `// Generated by Farm from ${label} for its React Native port. Do not edit.
+${output}`;
+  }
+  for (const tag of ["html", "body", ...[...tags].sort()]) {
+    const cascaded = _chunkV727H3RIcjs.cascadeFarmNativeStylesheetsForElement.call(void 0, sheets, { tag }, contextClasses);
+    problems.push(...cascaded.problems);
+    const entry2 = {
+      ...Object.keys(cascaded.style).length > 0 ? { style: cascaded.style } : {},
+      ...Object.keys(cascaded.dark).length > 0 ? { dark: cascaded.dark } : {},
+      ...cascaded.inherit.length > 0 ? { inherit: cascaded.inherit } : {}
+    };
+    if (Object.keys(entry2).length > 0) sheet[tag] = entry2;
+  }
+  if (problems.length > 0) return { problems: [...new Set(problems)] };
+  const hasMetadata = page.program.body.some(
+    (statement) => statement.type === "ExportNamedDeclaration" && _optionalChain([statement, 'access', _7 => _7.declaration, 'optionalAccess', _8 => _8.declarations, 'optionalAccess', _9 => _9.some, 'call', _10 => _10(
+      (declaration) => _optionalChain([declaration, 'access', _11 => _11.id, 'optionalAccess', _12 => _12.name]) === "metadata"
+    )])
+  );
+  const entry = `${options.module}.port.tsx`;
+  const pageImport = specifierBetween(_path2.default.join(portsDir, entry), copyOf(graph.page));
+  files[entry] = [
+    `// Generated by Farm: the React Native port of ${posix(_path2.default.relative(root, graph.page))}. Do not edit.`,
+    'import { useRouteParams } from "@farm.js/native";',
+    'import { FarmDomScreen } from "@farm.js/native/elements";',
+    `import Page from ${JSON.stringify(pageImport)};`,
+    ...hasMetadata ? [`export { metadata } from ${JSON.stringify(pageImport)};`] : [],
+    "",
+    "// The app's CSS for each element the page renders, light and dark.",
+    `const sheet = ${JSON.stringify(sheet)};`,
+    "",
+    "export default function FarmPort() {",
+    "  return (",
+    `    <FarmDomScreen sheet={sheet}${tailwind ? " preflight" : ""}>`,
+    "      <Page params={useRouteParams()} />",
+    "    </FarmDomScreen>",
+    "  );",
+    "}",
+    ""
+  ].join("\n");
+  return { port: { entry, files } };
+}
+
+
+exports.emitFarmMobilePort = emitFarmMobilePort;

package/dist/production-runtime.d-CcQiDko5.d.mts

@@ -0,0 +1,123 @@
+import { bi as ReadonlyMiddlewareStore, bj as FarmMiddlewareConfig, bk as MiddlewareModule, bl as MiddlewareConfig, bm as MiddlewareContext } from './client-plugins.d-CWyYBxXf.mjs';
+import { R as ResolvedFarmI18nConfig } from './types.d-C41ePjvP.mjs';
+import { R as ResolvedFarmServerConfig } from './workflows.d-CRMzQZ3k.mjs';
+
+/**
+ * Server-side middleware utilities for accessing middleware data in pages
+ */
+
+type MiddlewareStoreInput = Record<string, any> | Map<string, any>;
+/**
+ * Internal: Run code with middleware data available
+ * This is called by the server renderer
+ */
+declare function _runWithMiddlewareData<T>(data: MiddlewareStoreInput, fn: () => T | Promise<T>): Promise<T>;
+/** Internal: Run code with server-only middleware context available. */
+declare function _runWithMiddlewareContext<T>(context: MiddlewareStoreInput, fn: () => T | Promise<T>): Promise<T>;
+/**
+ * Get middleware data in a server component
+ * No props needed - uses global storage!
+ *
+ * @example
+ * ```tsx
+ * import { getMiddlewareData } from 'farm/middleware';
+ *
+ * export default function Page() {
+ *   const data = getMiddlewareData();  // ← No props needed!
+ *   const user = data.get('user');
+ *   const demoInfo = data.get('demoInfo');
+ *
+ *   return <div>Welcome {user?.name}</div>;
+ * }
+ * ```
+ */
+declare function getMiddlewareData<T extends Record<string, any> = Record<string, any>>(): Map<keyof T, T[keyof T]>;
+/**
+ * Get a specific value from middleware data (synchronous)
+ * Uses AsyncLocalStorage for request scoping - no props needed.
+ *
+ * @example
+ * ```tsx
+ * import { getMiddlewareValue } from 'farm/middleware';
+ *
+ * export default function Page() {
+ *   const user = getMiddlewareValue<User>('user');  // ← No props needed!
+ *   const stats = getMiddlewareValue('dashboardStats');
+ *
+ *   return <div>Welcome {user?.name}</div>;
+ * }
+ * ```
+ */
+declare function getMiddlewareValue<T = any>(key: string): T | undefined;
+/**
+ * Read server-only values set by route middleware for the current request.
+ * The returned store is available to the matched page, layouts, and nested
+ * Server Components, but is never added to hydration props.
+ */
+declare function getMiddlewareContext<T extends Record<string, any> = Record<string, any>>(): ReadonlyMiddlewareStore<T>;
+
+interface ProductionMiddlewareModuleEntry {
+    path: string;
+    filePath?: string;
+    module: MiddlewareModule | Record<string, any>;
+}
+interface ProductionMiddlewareRunnerOptions {
+    config?: FarmMiddlewareConfig | null;
+    modules?: ProductionMiddlewareModuleEntry[];
+    i18n?: ResolvedFarmI18nConfig;
+    server?: Pick<ResolvedFarmServerConfig, "trustProxy">;
+    /** The app's public API path (`api.basePath`); `/api` middleware guards it too. */
+    apiBasePath?: string;
+    /**
+     * @internal The app matches pages against the request path as received, without stripping
+     * basePath or locale (the RSC entry), so middleware matches that path too.
+     */
+    rawPathRouting?: boolean;
+}
+interface ProductionMiddlewareRequestOptions {
+    /**
+     * The address of the peer that opened the connection, as the server adapter
+     * reports it. A web Request carries no socket, so this is the only way a
+     * built app's middleware learns the client address it already has in
+     * development. A trusted proxy's `x-forwarded-for` still takes precedence.
+     */
+    clientAddress?: string;
+}
+interface ProductionMiddlewareResult {
+    request: Request;
+    response: Response | null;
+    data: Map<string, any>;
+    context: Map<string, any>;
+    headers: Headers;
+    handled: boolean;
+    /**
+     * Middleware without `cache: "public"` ran and let the request through. It may have been a
+     * guard (an IP allowlist, an API key header), so the response must not reach a shared cache.
+     */
+    guarded: boolean;
+    /** Middleware called notFound(): answer with the app's not-found page. */
+    notFound?: true;
+}
+/**
+ * Decide whether a middleware entry's `export const config` applies to a path.
+ *
+ * Exported so the standalone dev plugin matches exactly what the production
+ * runner does instead of maintaining a parallel implementation.
+ */
+declare function matchesMiddlewareConfig(pathname: string, config: MiddlewareConfig, ctx: MiddlewareContext): {
+    matched: boolean;
+    params?: Record<string, string>;
+};
+declare function createProductionMiddlewareRunner(options?: ProductionMiddlewareRunnerOptions): (request: Request, requestOptions?: ProductionMiddlewareRequestOptions) => Promise<ProductionMiddlewareResult>;
+declare function applyProductionMiddlewareHeaders(response: Response, middlewareHeaders?: Headers | null): Response;
+/**
+ * Keep a response that middleware let through out of shared caches. A CDN keys its copy by URL
+ * and serves it without running the guard again, so a page an IP allowlist or API key header
+ * let one visitor read would reach everyone. A Cache-Control that a shared cache may store
+ * becomes `private, no-store`; a private one is left as it is.
+ *
+ * @internal
+ */
+declare function _withFarmGuardedResponseCache(response: Response): Response;
+
+export { _runWithMiddlewareContext as _, _runWithMiddlewareData as a, applyProductionMiddlewareHeaders as b, createProductionMiddlewareRunner as c, getMiddlewareData as d, getMiddlewareValue as e, _withFarmGuardedResponseCache as f, getMiddlewareContext as g, matchesMiddlewareConfig as m };

package/dist/production-runtime.d-DgT24A0f.d.ts

@@ -0,0 +1,123 @@
+import { bi as ReadonlyMiddlewareStore, bj as FarmMiddlewareConfig, bk as MiddlewareModule, bl as MiddlewareConfig, bm as MiddlewareContext } from './client-plugins.d-BcqIy4au.js';
+import { R as ResolvedFarmI18nConfig } from './types.d-C41ePjvP.js';
+import { R as ResolvedFarmServerConfig } from './workflows.d-CRMzQZ3k.js';
+
+/**
+ * Server-side middleware utilities for accessing middleware data in pages
+ */
+
+type MiddlewareStoreInput = Record<string, any> | Map<string, any>;
+/**
+ * Internal: Run code with middleware data available
+ * This is called by the server renderer
+ */
+declare function _runWithMiddlewareData<T>(data: MiddlewareStoreInput, fn: () => T | Promise<T>): Promise<T>;
+/** Internal: Run code with server-only middleware context available. */
+declare function _runWithMiddlewareContext<T>(context: MiddlewareStoreInput, fn: () => T | Promise<T>): Promise<T>;
+/**
+ * Get middleware data in a server component
+ * No props needed - uses global storage!
+ *
+ * @example
+ * ```tsx
+ * import { getMiddlewareData } from 'farm/middleware';
+ *
+ * export default function Page() {
+ *   const data = getMiddlewareData();  // ← No props needed!
+ *   const user = data.get('user');
+ *   const demoInfo = data.get('demoInfo');
+ *
+ *   return <div>Welcome {user?.name}</div>;
+ * }
+ * ```
+ */
+declare function getMiddlewareData<T extends Record<string, any> = Record<string, any>>(): Map<keyof T, T[keyof T]>;
+/**
+ * Get a specific value from middleware data (synchronous)
+ * Uses AsyncLocalStorage for request scoping - no props needed.
+ *
+ * @example
+ * ```tsx
+ * import { getMiddlewareValue } from 'farm/middleware';
+ *
+ * export default function Page() {
+ *   const user = getMiddlewareValue<User>('user');  // ← No props needed!
+ *   const stats = getMiddlewareValue('dashboardStats');
+ *
+ *   return <div>Welcome {user?.name}</div>;
+ * }
+ * ```
+ */
+declare function getMiddlewareValue<T = any>(key: string): T | undefined;
+/**
+ * Read server-only values set by route middleware for the current request.
+ * The returned store is available to the matched page, layouts, and nested
+ * Server Components, but is never added to hydration props.
+ */
+declare function getMiddlewareContext<T extends Record<string, any> = Record<string, any>>(): ReadonlyMiddlewareStore<T>;
+
+interface ProductionMiddlewareModuleEntry {
+    path: string;
+    filePath?: string;
+    module: MiddlewareModule | Record<string, any>;
+}
+interface ProductionMiddlewareRunnerOptions {
+    config?: FarmMiddlewareConfig | null;
+    modules?: ProductionMiddlewareModuleEntry[];
+    i18n?: ResolvedFarmI18nConfig;
+    server?: Pick<ResolvedFarmServerConfig, "trustProxy">;
+    /** The app's public API path (`api.basePath`); `/api` middleware guards it too. */
+    apiBasePath?: string;
+    /**
+     * @internal The app matches pages against the request path as received, without stripping
+     * basePath or locale (the RSC entry), so middleware matches that path too.
+     */
+    rawPathRouting?: boolean;
+}
+interface ProductionMiddlewareRequestOptions {
+    /**
+     * The address of the peer that opened the connection, as the server adapter
+     * reports it. A web Request carries no socket, so this is the only way a
+     * built app's middleware learns the client address it already has in
+     * development. A trusted proxy's `x-forwarded-for` still takes precedence.
+     */
+    clientAddress?: string;
+}
+interface ProductionMiddlewareResult {
+    request: Request;
+    response: Response | null;
+    data: Map<string, any>;
+    context: Map<string, any>;
+    headers: Headers;
+    handled: boolean;
+    /**
+     * Middleware without `cache: "public"` ran and let the request through. It may have been a
+     * guard (an IP allowlist, an API key header), so the response must not reach a shared cache.
+     */
+    guarded: boolean;
+    /** Middleware called notFound(): answer with the app's not-found page. */
+    notFound?: true;
+}
+/**
+ * Decide whether a middleware entry's `export const config` applies to a path.
+ *
+ * Exported so the standalone dev plugin matches exactly what the production
+ * runner does instead of maintaining a parallel implementation.
+ */
+declare function matchesMiddlewareConfig(pathname: string, config: MiddlewareConfig, ctx: MiddlewareContext): {
+    matched: boolean;
+    params?: Record<string, string>;
+};
+declare function createProductionMiddlewareRunner(options?: ProductionMiddlewareRunnerOptions): (request: Request, requestOptions?: ProductionMiddlewareRequestOptions) => Promise<ProductionMiddlewareResult>;
+declare function applyProductionMiddlewareHeaders(response: Response, middlewareHeaders?: Headers | null): Response;
+/**
+ * Keep a response that middleware let through out of shared caches. A CDN keys its copy by URL
+ * and serves it without running the guard again, so a page an IP allowlist or API key header
+ * let one visitor read would reach everyone. A Cache-Control that a shared cache may store
+ * becomes `private, no-store`; a private one is left as it is.
+ *
+ * @internal
+ */
+declare function _withFarmGuardedResponseCache(response: Response): Response;
+
+export { _runWithMiddlewareContext as _, _runWithMiddlewareData as a, applyProductionMiddlewareHeaders as b, createProductionMiddlewareRunner as c, getMiddlewareData as d, getMiddlewareValue as e, _withFarmGuardedResponseCache as f, getMiddlewareContext as g, matchesMiddlewareConfig as m };

package/dist/production-vite.d-BQFAlG7n.d.mts

@@ -0,0 +1,13 @@
+import { build, createServer, loadEnv } from 'vite';
+
+type FarmProductionViteBuilder = "rolldown";
+interface FarmProductionViteRuntime {
+    build: typeof build;
+    createServer: typeof createServer;
+    loadEnv: typeof loadEnv;
+    builder: FarmProductionViteBuilder;
+}
+/** Load the Vite runtime Farm uses for development, route discovery, and production bundles. */
+declare function loadFarmProductionVite(): Promise<FarmProductionViteRuntime>;
+
+export { type FarmProductionViteRuntime as F, loadFarmProductionVite as l };