@farm.js/core 0.1.61 → 0.1.62

package/dist/chunk-Z7P2BTZ3.cjs

@@ -0,0 +1,454 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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 _chunk5C7XMKQ4cjs = require('./chunk-5C7XMKQ4.cjs');
+
+
+var _chunkJXIYH2NOcjs = require('./chunk-JXIYH2NO.cjs');
+
+
+var _chunk4DCWVSL2cjs = require('./chunk-4DCWVSL2.cjs');
+
+
+
+
+var _chunkITV4QQL2cjs = require('./chunk-ITV4QQL2.cjs');
+
+
+var _chunk2OF5RPVUcjs = require('./chunk-2OF5RPVU.cjs');
+
+
+
+
+
+var _chunkCFG4QERRcjs = require('./chunk-CFG4QERR.cjs');
+
+
+
+var _chunkCA7DNRHOcjs = require('./chunk-CA7DNRHO.cjs');
+
+
+
+var _chunkPMJSG4JScjs = require('./chunk-PMJSG4JS.cjs');
+
+
+
+
+var _chunkUZCMMJJTcjs = require('./chunk-UZCMMJJT.cjs');
+
+
+var _chunkHNAISJFDcjs = require('./chunk-HNAISJFD.cjs');
+
+// src/api/plugin-route-runtime.ts
+function mergePluginAPIRoutes(existing, plugins, expected, options = {}) {
+  const routes = /* @__PURE__ */ new Map();
+  const shapes = /* @__PURE__ */ new Map();
+  for (const route of existing) {
+    _chunkJXIYH2NOcjs.registerAPIRouteShape.call(void 0, shapes, route.path, route.filePath || route.path, "app");
+    routes.set(route.path, {
+      ...route,
+      filePath: route.filePath || "",
+      methods: [...route.methods],
+      endpoints: { ...route.endpoints }
+    });
+  }
+  const api = createPluginLocalAPI(existing, options.bodySizeLimit, options.dispatch);
+  for (const definition of _chunk5C7XMKQ4cjs.resolvePluginRoutes.call(void 0, plugins, { api })) {
+    _chunkJXIYH2NOcjs.registerAPIRouteShape.call(void 0, shapes, definition.path, `plugin:${definition.path}`, "app");
+    let route = routes.get(definition.path);
+    if (_optionalChain([route, 'optionalAccess', _ => _.methods, 'access', _2 => _2.includes, 'call', _3 => _3(definition.method)])) {
+      throw new Error(
+        `Duplicate API route for ${definition.method} ${definition.path}. Plugin routes cannot override app or other plugin endpoints.`
+      );
+    }
+    if (!route) {
+      route = { path: definition.path, filePath: "", methods: [], endpoints: {} };
+      routes.set(definition.path, route);
+    }
+    route.methods.push(definition.method);
+    route.pluginMethods = [..._nullishCoalesce(route.pluginMethods, () => ( [])), definition.method];
+    route.endpoints[definition.method] = definition.endpoint;
+  }
+  const result = [...routes.values()];
+  if (expected) {
+    const signature = (entries) => entries.map(({ path, methods }) => `${path}:${[...methods].sort().join(",")}`).sort().join("\n");
+    const actualSignature = signature(result);
+    const expectedSignature = signature(expected);
+    if (actualSignature !== expectedSignature) {
+      throw new Error(
+        `Plugin API routes changed between build and runtime. Route paths and methods must be stable across environments; rebuild the app.
+Expected:
+${expectedSignature || "(none)"}
+Received:
+${actualSignature || "(none)"}`
+      );
+    }
+  }
+  return result;
+}
+var DISPATCH_DROPPED_HEADERS = [
+  "accept-encoding",
+  "connection",
+  "content-length",
+  "keep-alive",
+  "proxy-connection",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade"
+];
+function createPluginLocalAPI(routes, bodySizeLimit, dispatch) {
+  const endpoints = /* @__PURE__ */ new Map();
+  for (const route of routes) {
+    for (const method of route.methods) {
+      const normalizedMethod = method.toUpperCase();
+      const endpoint = route.endpoints[normalizedMethod];
+      if (typeof endpoint !== "function") continue;
+      const descriptor = Object.freeze({
+        path: route.path,
+        method: normalizedMethod,
+        input: Object.freeze({
+          body: _optionalChain([endpoint, 'access', _4 => _4.__types, 'optionalAccess', _5 => _5.body]),
+          query: _optionalChain([endpoint, 'access', _6 => _6.__types, 'optionalAccess', _7 => _7.query]),
+          params: _optionalChain([endpoint, 'access', _8 => _8.__types, 'optionalAccess', _9 => _9.params]),
+          headers: _optionalChain([endpoint, 'access', _10 => _10.__types, 'optionalAccess', _11 => _11.headers])
+        }),
+        output: endpoint.__output,
+        mcp: endpoint.__mcp === true ? true : endpoint.__mcp ? Object.freeze({ ...endpoint.__mcp }) : void 0,
+        async invoke(request, params = {}) {
+          if (!dispatch)
+            return invokeAPIRouteEndpoint(endpoint, request, { ...params }, bodySizeLimit);
+          const headers = new Headers(request.headers);
+          for (const name of DISPATCH_DROPPED_HEADERS) headers.delete(name);
+          return dispatch(new Request(request, { headers }));
+        }
+      });
+      endpoints.set(`${normalizedMethod} ${route.path}`, descriptor);
+    }
+  }
+  const listedEndpoints = Object.freeze(Array.from(endpoints.values()));
+  return Object.freeze({
+    available: true,
+    get(method, path) {
+      return endpoints.get(`${method.toUpperCase()} ${path}`);
+    },
+    list() {
+      return listedEndpoints;
+    }
+  });
+}
+
+// src/api/runtime.ts
+var API_ROUTE_METHODS = [
+  "GET",
+  "HEAD",
+  "QUERY",
+  "POST",
+  "PUT",
+  "DELETE",
+  "PATCH",
+  "OPTIONS"
+];
+function resolveAPIRouteEndpoint(route, method) {
+  const normalizedMethod = method.toUpperCase();
+  return _nullishCoalesce(route.endpoints[normalizedMethod], () => ( (normalizedMethod === "HEAD" ? route.endpoints.GET : void 0)));
+}
+function getAllowedAPIRouteMethods(route) {
+  const methods = [...route.methods];
+  const getIndex = methods.indexOf("GET");
+  if (getIndex >= 0 && !methods.includes("HEAD")) {
+    methods.splice(getIndex + 1, 0, "HEAD");
+  }
+  return methods;
+}
+function matchAPIRouteAtBasePath(routes, pathname, serverBasePath = _chunkPMJSG4JScjs.DEFAULT_FARM_API_BASE_PATH) {
+  const directMatch = _chunkCA7DNRHOcjs.matchAPIRoute.call(void 0, routes, pathname);
+  if (directMatch) return directMatch;
+  const canonicalPathname = _chunk2OF5RPVUcjs.resolveFarmAPICanonicalPathname.call(void 0, pathname, serverBasePath);
+  return canonicalPathname === pathname ? null : _chunkCA7DNRHOcjs.matchAPIRoute.call(void 0, routes, canonicalPathname);
+}
+function createStaticAPIRouteMatcherAtBasePath(routes, serverBasePath = _chunkPMJSG4JScjs.DEFAULT_FARM_API_BASE_PATH) {
+  const match = _chunkCA7DNRHOcjs.createStaticAPIRouteMatcher.call(void 0, routes);
+  return (pathname) => {
+    const directMatch = match(pathname);
+    if (directMatch) return directMatch;
+    const canonicalPathname = _chunk2OF5RPVUcjs.resolveFarmAPICanonicalPathname.call(void 0, pathname, serverBasePath);
+    return canonicalPathname === pathname ? null : match(canonicalPathname);
+  };
+}
+function isFarmAPIPathname(pathname, serverBasePath = _chunkPMJSG4JScjs.DEFAULT_FARM_API_BASE_PATH) {
+  const basePath = _chunkPMJSG4JScjs.normalizeFarmAPIBasePath.call(void 0, serverBasePath);
+  return basePath !== "/" && (pathname === basePath || pathname.startsWith(`${basePath}/`));
+}
+async function invokeAPIRouteEndpoint(endpoint, request, params = {}, bodySizeLimit = _chunkCFG4QERRcjs.DEFAULT_FARM_SERVER_BODY_SIZE_LIMIT) {
+  try {
+    request = await _chunkCFG4QERRcjs.bufferFarmRequestBody.call(void 0, request, bodySizeLimit);
+  } catch (error) {
+    const response2 = _chunkCFG4QERRcjs.createFarmRequestBodyErrorResponse.call(void 0, error);
+    if (response2) return response2;
+    throw error;
+  }
+  const response = await _chunkHNAISJFDcjs._runWithCurrentRequest.call(void 0, 
+    request,
+    () => invokeAPIRouteEndpointInContext(endpoint, request, params)
+  );
+  if (request.method.toUpperCase() !== "HEAD") {
+    return response;
+  }
+  return _chunk4DCWVSL2cjs.omitFarmResponseBody.call(void 0, response);
+}
+async function invokeAPIRouteEndpointInContext(endpoint, request, params) {
+  const queryContentTypeError = validateQueryContentType(request);
+  if (queryContentTypeError) {
+    return queryContentTypeError;
+  }
+  const farmHandler = endpoint.__handler || null;
+  if (!farmHandler) {
+    const result = await endpoint(request, {
+      params: Promise.resolve(params)
+    });
+    return normalizeRouteResponse(result);
+  }
+  const url = new URL(request.url);
+  const query = {
+    ...searchParamsToObject(url.searchParams)
+  };
+  let body = void 0;
+  if (request.method.toUpperCase() !== "GET" && request.method.toUpperCase() !== "HEAD") {
+    const parsedBody = await readRequestBody(request);
+    if (parsedBody.error) return parsedBody.error;
+    body = parsedBody.body;
+  }
+  const headers = Object.fromEntries(request.headers.entries());
+  const types = endpoint.__types || {};
+  const queryValidation = await validateInput(types.query, query, "Invalid query parameters");
+  if (queryValidation instanceof Response) {
+    return queryValidation;
+  }
+  const bodyValidation = await validateInput(types.body, body, "Invalid request body");
+  if (bodyValidation instanceof Response) {
+    return bodyValidation;
+  }
+  const headersValidation = await validateInput(types.headers, headers, "Invalid request headers");
+  if (headersValidation instanceof Response) {
+    return headersValidation;
+  }
+  const paramsValidation = await validateInput(types.params, params, "Invalid route parameters");
+  if (paramsValidation instanceof Response) return paramsValidation;
+  const handlerContext = {
+    query: queryValidation,
+    body: bodyValidation,
+    headers: headersValidation,
+    request,
+    context: {},
+    params: paramsValidation
+  };
+  let execution;
+  try {
+    execution = typeof endpoint.__farmInvoke === "function" ? await endpoint.__farmInvoke(handlerContext) : {
+      result: await farmHandler(handlerContext),
+      context: handlerContext.context,
+      handlerExecuted: true,
+      invalidations: []
+    };
+  } catch (error) {
+    if (_chunk5C7XMKQ4cjs.isEndpointFailure.call(void 0, error)) {
+      return createEndpointFailureResponse(error);
+    }
+    throw error;
+  }
+  if (execution.handlerExecuted && endpoint.__output && !isWebResponse(execution.result)) {
+    try {
+      execution.result = await _chunkITV4QQL2cjs.parseRouteSchema.call(void 0, endpoint.__output, execution.result);
+    } catch (e) {
+      throw new Error("API route returned a value that does not match its output schema.");
+    }
+  }
+  const response = normalizeRouteResponse(execution.result);
+  return attachEndpointInvalidations(response, execution.invalidations);
+}
+function validateQueryContentType(request) {
+  if (request.method.toUpperCase() !== "QUERY" || request.headers.has("content-type")) {
+    return null;
+  }
+  return new Response(
+    JSON.stringify({
+      error: "Invalid QUERY request",
+      message: "QUERY requests must include a Content-Type header."
+    }),
+    {
+      status: 400,
+      headers: { "Content-Type": "application/json" }
+    }
+  );
+}
+function normalizeRouteResponse(result) {
+  if (isWebResponse(result)) {
+    return result;
+  }
+  if (result === void 0) {
+    return new Response(null, { status: 204 });
+  }
+  let body;
+  try {
+    body = JSON.stringify(result);
+  } catch (error) {
+    const serializationError = new TypeError(
+      "API route result must be a JSON-serializable value or a Response."
+    );
+    serializationError.cause = error;
+    throw serializationError;
+  }
+  if (body === void 0) {
+    throw new TypeError("API route result must be a JSON-serializable value or a Response.");
+  }
+  return new Response(body, {
+    status: 200,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+function isWebResponse(value) {
+  return value instanceof Response || typeof value === "object" && value !== null && "headers" in value && "status" in value && typeof value.arrayBuffer === "function";
+}
+function attachEndpointInvalidations(response, keys) {
+  const existing = _chunkUZCMMJJTcjs.decodeFarmCacheInvalidations.call(void 0, 
+    response.headers.get(_chunkUZCMMJJTcjs.FARM_CACHE_INVALIDATION_HEADER)
+  );
+  const encoded = _chunkUZCMMJJTcjs.encodeFarmCacheInvalidations.call(void 0, [...existing, ...keys]);
+  if (!encoded) return response;
+  const headers = new Headers(response.headers);
+  headers.set(_chunkUZCMMJJTcjs.FARM_CACHE_INVALIDATION_HEADER, encoded);
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+function createEndpointFailureResponse(failure) {
+  return new Response(
+    JSON.stringify({
+      error: {
+        code: failure.code,
+        message: failure.message,
+        data: failure.data
+      }
+    }),
+    {
+      status: failure.status,
+      headers: {
+        "cache-control": "no-store",
+        "content-type": "application/json"
+      }
+    }
+  );
+}
+async function readRequestBody(request) {
+  const contentType = _optionalChain([request, 'access', _12 => _12.headers, 'access', _13 => _13.get, 'call', _14 => _14("content-type"), 'optionalAccess', _15 => _15.split, 'call', _16 => _16(";", 1), 'access', _17 => _17[0], 'optionalAccess', _18 => _18.trim, 'call', _19 => _19(), 'access', _20 => _20.toLowerCase, 'call', _21 => _21()]);
+  if (contentType === "multipart/form-data") {
+    try {
+      return { body: formDataToObject(await _chunkCFG4QERRcjs.cloneFarmRequest.call(void 0, request).formData()) };
+    } catch (e2) {
+      return invalidRequestBody("The request body is not valid multipart form data.");
+    }
+  }
+  let text;
+  try {
+    text = await _chunkCFG4QERRcjs.cloneFarmRequest.call(void 0, request).text();
+  } catch (e3) {
+    if (contentType === "application/json" || _optionalChain([contentType, 'optionalAccess', _22 => _22.endsWith, 'call', _23 => _23("+json")])) {
+      return invalidRequestBody("The request body is not valid JSON.");
+    }
+    if (contentType === "application/x-www-form-urlencoded") {
+      return invalidRequestBody("The request body is not valid URL-encoded form data.");
+    }
+    return { body: void 0 };
+  }
+  if (contentType === "application/json" || _optionalChain([contentType, 'optionalAccess', _24 => _24.endsWith, 'call', _25 => _25("+json")])) {
+    if (!text && request.method.toUpperCase() === "QUERY") {
+      return { body: void 0 };
+    }
+    try {
+      return { body: JSON.parse(text) };
+    } catch (e4) {
+      return invalidRequestBody("The request body is not valid JSON.");
+    }
+  }
+  if (contentType === "application/x-www-form-urlencoded") {
+    return { body: searchParamsToObject(new URLSearchParams(text)) };
+  }
+  if (!text) return { body: void 0 };
+  if (contentType === void 0) {
+    if (!_chunkITV4QQL2cjs.validateIntegrationRequestOrigin.call(void 0, request, { requireOriginMetadata: false }).ok) {
+      return { body: void 0 };
+    }
+    try {
+      return { body: JSON.parse(text) };
+    } catch (e5) {
+      return { body: void 0 };
+    }
+  }
+  return { body: void 0 };
+}
+function invalidRequestBody(message) {
+  return {
+    error: new Response(
+      JSON.stringify({
+        error: "Invalid request body",
+        message
+      }),
+      {
+        status: 400,
+        headers: { "Content-Type": "application/json" }
+      }
+    )
+  };
+}
+function formDataToObject(formData) {
+  return entriesToObject(formData.entries());
+}
+function searchParamsToObject(searchParams) {
+  return entriesToObject(searchParams.entries());
+}
+function entriesToObject(entries) {
+  const output = /* @__PURE__ */ Object.create(null);
+  for (const [key, value] of entries) {
+    if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
+    const current = output[key];
+    if (current === void 0) {
+      output[key] = value;
+    } else if (Array.isArray(current)) {
+      current.push(value);
+    } else {
+      output[key] = [current, value];
+    }
+  }
+  return output;
+}
+async function validateInput(schema, value, error) {
+  if (!schema) return value;
+  try {
+    return await _chunkITV4QQL2cjs.parseRouteSchema.call(void 0, schema, value);
+  } catch (validationError) {
+    return Response.json(
+      {
+        error,
+        details: _chunkITV4QQL2cjs.toPublicValidationIssues.call(void 0, validationError)
+      },
+      { status: 400 }
+    );
+  }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.API_ROUTE_METHODS = API_ROUTE_METHODS; exports.resolveAPIRouteEndpoint = resolveAPIRouteEndpoint; exports.getAllowedAPIRouteMethods = getAllowedAPIRouteMethods; exports.matchAPIRouteAtBasePath = matchAPIRouteAtBasePath; exports.createStaticAPIRouteMatcherAtBasePath = createStaticAPIRouteMatcherAtBasePath; exports.isFarmAPIPathname = isFarmAPIPathname; exports.invokeAPIRouteEndpoint = invokeAPIRouteEndpoint; exports.normalizeRouteResponse = normalizeRouteResponse; exports.isWebResponse = isWebResponse; exports.createEndpointFailureResponse = createEndpointFailureResponse; exports.mergePluginAPIRoutes = mergePluginAPIRoutes;

package/dist/chunk-ZBUAOGMY.mjs

@@ -0,0 +1,156 @@
+import {
+  FARM_RSC_INSTALL_HINT,
+  findFarmAppPackageDir
+} from "./chunk-UR25Z5Z6.mjs";
+import {
+  createFarmDevLoopbackPlugin
+} from "./chunk-FN5UEC7I.mjs";
+import {
+  resolveDeployOutputPath
+} from "./chunk-VWW4Q3BJ.mjs";
+import {
+  farmDesktopDevGuardPlugin,
+  loadFarmReactPlugin
+} from "./chunk-QOSDWGKT.mjs";
+import {
+  loadTailwindVitePlugin
+} from "./chunk-OM7WILES.mjs";
+import {
+  resolveFarmPlatform
+} from "./chunk-SMUW7UST.mjs";
+
+// src/rsc-pipeline.ts
+import { readFileSync } from "fs";
+import path from "path";
+import { pathToFileURL } from "url";
+var FARM_RSC_ENTRIES = {
+  rsc: "./.farm/rsc-entries/entry.rsc.tsx",
+  ssr: "./.farm/rsc-entries/entry.ssr.tsx",
+  client: "./.farm/rsc-entries/entry.browser.tsx"
+};
+var FARM_RSC_CONFIG_KEYS = [
+  "srcDir",
+  "extends",
+  "basePath",
+  "api",
+  "server",
+  "middleware",
+  "images",
+  "serverActions",
+  "deploymentId",
+  "generateBuildId",
+  "md",
+  "agent",
+  "mcp"
+];
+var FARM_RSC_PASSTHROUGH_KEYS = ["i18n", "cache"];
+function pickImportTarget(entry) {
+  if (typeof entry === "string") return entry;
+  if (!entry || typeof entry !== "object") return void 0;
+  for (const condition of ["import", "node", "default"]) {
+    const target = pickImportTarget(entry[condition]);
+    if (target) return target;
+  }
+  return void 0;
+}
+async function importFromApp(root, packageName, subpath = ".") {
+  const packageDir = findFarmAppPackageDir(root, packageName);
+  if (!packageDir) return void 0;
+  const manifest = JSON.parse(readFileSync(path.join(packageDir, "package.json"), "utf8"));
+  const exportsMap = manifest.exports;
+  const entry = exportsMap && typeof exportsMap === "object" && !Array.isArray(exportsMap) && subpath in exportsMap ? exportsMap[subpath] : subpath === "." ? exportsMap ?? manifest.module ?? manifest.main ?? "index.js" : void 0;
+  const target = pickImportTarget(entry);
+  if (!target) return void 0;
+  return import(pathToFileURL(path.join(packageDir, target)).href);
+}
+function hasPluginNamed(plugins, prefix) {
+  if (Array.isArray(plugins)) return plugins.some((plugin) => hasPluginNamed(plugin, prefix));
+  const name = plugins?.name;
+  return typeof name === "string" && name.startsWith(prefix);
+}
+async function createFarmRscViteConfig(userConfig, options) {
+  const root = path.resolve(options.root);
+  const renderer = userConfig.renderer;
+  if (renderer && typeof renderer === "object" && renderer.name && renderer.name !== "react") {
+    throw new Error(
+      `[Farm.js] experimental.serverComponents needs the React renderer; this app uses "${renderer.name}".`
+    );
+  }
+  const [pluginRsc, viteRsc, viteReact] = await Promise.all([
+    importFromApp(root, "@farm.js/plugin", "./rsc"),
+    importFromApp(root, "@vitejs/plugin-rsc"),
+    importFromApp(root, "@vitejs/plugin-react")
+  ]);
+  if (!pluginRsc || !viteRsc || !findFarmAppPackageDir(root, "react-server-dom-webpack")) {
+    throw new Error(
+      `[Farm.js] experimental.serverComponents runs on @farm.js/plugin and the official @vitejs/plugin-rsc. Install them: ${FARM_RSC_INSTALL_HINT}`
+    );
+  }
+  const { plugins: vitePlugins = [], ...viteOptions } = userConfig.vite ?? {};
+  const rscConfig = {};
+  for (const key of FARM_RSC_CONFIG_KEYS) {
+    if (userConfig[key] !== void 0) rscConfig[key] = userConfig[key];
+  }
+  const createReactPlugin = hasPluginNamed(vitePlugins, "vite:react") ? void 0 : viteReact?.default ?? (options.command === "serve" ? (await loadFarmReactPlugin()).default : void 0);
+  const tailwind = hasPluginNamed(vitePlugins, "@tailwindcss/vite") ? void 0 : await loadTailwindVitePlugin();
+  const platform = resolveFarmPlatform();
+  const mobileClient = userConfig.mobile === void 0 || platform === "desktop" ? void 0 : options.command === "build" ? "entry" : platform === "mobile" ? "inline" : void 0;
+  const farmConfig = pluginRsc.defineConfig({
+    ...rscConfig,
+    ...mobileClient ? { mobileClient } : {},
+    experimental: { ...userConfig.experimental, serverComponents: true },
+    port: options.port ?? userConfig.server?.port,
+    plugins: [
+      ...options.command === "serve" && platform === "desktop" ? [
+        farmDesktopDevGuardPlugin(
+          typeof userConfig.basePath === "string" ? userConfig.basePath : void 0
+        )
+      ] : [],
+      ...tailwind ? [tailwind] : [],
+      ...vitePlugins,
+      viteRsc.default({ serverHandler: false, entries: FARM_RSC_ENTRIES }),
+      ...typeof createReactPlugin === "function" ? [createReactPlugin()] : [],
+      pluginRsc.nitro({
+        server: { environmentName: "rsc" },
+        config: {
+          preset: options.preset,
+          outputDir: options.outputDir && resolveDeployOutputPath(root, options.outputDir)
+        }
+      })
+    ]
+  });
+  for (const key of FARM_RSC_PASSTHROUGH_KEYS) {
+    if (userConfig[key] !== void 0) farmConfig[key] = userConfig[key];
+  }
+  const { mergeConfig } = await import("vite");
+  return {
+    ...mergeConfig(farmConfig, viteOptions),
+    root,
+    // The Farm config is the app's config; a stray vite.config must not add a second pipeline.
+    configFile: false,
+    mode: options.command === "build" ? "production" : "development"
+  };
+}
+async function createFarmRscDevServer(userConfig, options) {
+  const { createServer } = await import("vite");
+  const { host, ...configOptions } = options;
+  const config = await createFarmRscViteConfig(userConfig, { ...configOptions, command: "serve" });
+  return createServer({
+    ...config,
+    plugins: [...config.plugins ?? [], createFarmDevLoopbackPlugin()],
+    ...host === void 0 ? {} : { server: { ...config.server, host } }
+  });
+}
+async function buildFarmRsc(userConfig, options) {
+  const { createBuilder } = await import("vite");
+  const builder = await createBuilder(
+    await createFarmRscViteConfig(userConfig, { ...options, command: "build" })
+  );
+  await builder.buildApp();
+}
+
+export {
+  createFarmRscViteConfig,
+  createFarmRscDevServer,
+  buildFarmRsc
+};

package/dist/chunk-ZDAEHG2O.cjs

@@ -0,0 +1,80 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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 _chunkQMNWKQL4cjs = require('./chunk-QMNWKQL4.cjs');
+
+// src/routing/route-slots.ts
+var SLOT_SEGMENT = /^@([A-Za-z][A-Za-z0-9_-]*)$/;
+function isRouteSlotSegment(segment) {
+  return SLOT_SEGMENT.test(segment);
+}
+function parseRouteSlotFile(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  const parts = normalized.split("/").filter(Boolean);
+  const fileName = _nullishCoalesce(parts.at(-1), () => ( ""));
+  const baseName = fileName.replace(/\.(tsx?|jsx?|vue|svelte)$/, "");
+  if (baseName !== "page" && baseName !== "default") return null;
+  const slotIndex = parts.findIndex((part) => SLOT_SEGMENT.test(part));
+  if (slotIndex < 0) return null;
+  if (parts.slice(slotIndex + 1, -1).some((part) => SLOT_SEGMENT.test(part))) {
+    throw new Error(`Nested route slots are not supported in "${filePath}"`);
+  }
+  const slotMatch = parts[slotIndex].match(SLOT_SEGMENT);
+  const name = _optionalChain([slotMatch, 'optionalAccess', _ => _[1]]);
+  if (!name) return null;
+  const ownerParts = parts.slice(0, slotIndex);
+  const contentParts = parts.slice(slotIndex + 1, -1);
+  const marker = parseInterceptionMarker(contentParts[0]);
+  let targetBase = ownerParts;
+  let targetParts = contentParts;
+  if (marker) {
+    targetBase = marker.root === true ? [] : ownerParts.slice(0, Math.max(0, ownerParts.length - marker.up));
+    targetParts = [...marker.remainder ? [marker.remainder] : [], ...contentParts.slice(1)];
+  }
+  const ownerFile = [...ownerParts, "layout.tsx"].join("/");
+  const routeFile = [
+    ...baseName === "default" ? ownerParts : targetBase,
+    ...baseName === "default" ? [] : targetParts,
+    "page.tsx"
+  ].join("/");
+  return {
+    name,
+    ownerRoute: _chunkQMNWKQL4cjs.parseRoutePath.call(void 0, ownerFile || "layout.tsx"),
+    route: _chunkQMNWKQL4cjs.parseRoutePath.call(void 0, routeFile || "page.tsx"),
+    interception: marker !== null,
+    fallback: baseName === "default"
+  };
+}
+function createRouteSlotContainerId(name, ownerPattern) {
+  const owner = ownerPattern === "/" ? "root" : ownerPattern.replace(/^\//, "").replace(/[^A-Za-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "");
+  return `__farm_slot_${name}_${owner || "root"}__`;
+}
+function parseInterceptionMarker(segment) {
+  if (!segment) return null;
+  if (segment.startsWith("(...)")) {
+    return {
+      up: 0,
+      root: true,
+      remainder: segment.slice(5)
+    };
+  }
+  if (segment.startsWith("(.)")) {
+    return {
+      up: 0,
+      remainder: segment.slice(3)
+    };
+  }
+  let remainder = segment;
+  let up = 0;
+  while (remainder.startsWith("(..)")) {
+    up += 1;
+    remainder = remainder.slice(4);
+  }
+  return up > 0 ? { up, remainder } : null;
+}
+
+
+
+
+
+
+exports.isRouteSlotSegment = isRouteSlotSegment; exports.parseRouteSlotFile = parseRouteSlotFile; exports.createRouteSlotContainerId = createRouteSlotContainerId; exports.parseInterceptionMarker = parseInterceptionMarker;