@farm.js/core 0.1.46 → 0.1.48

package/dist/chunk-6M3HXUBQ.mjs

@@ -0,0 +1,135 @@
+import {
+  FARM_RSC_INSTALL_HINT,
+  findFarmAppPackageDir
+} from "./chunk-PXEXOQ5R.mjs";
+import {
+  resolveDeployOutputPath
+} from "./chunk-VJXLUTBM.mjs";
+import {
+  loadFarmReactPlugin
+} from "./chunk-XLYXG73A.mjs";
+import {
+  loadTailwindVitePlugin
+} from "./chunk-XLLVWLWO.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 farmConfig = pluginRsc.defineConfig({
+    ...rscConfig,
+    experimental: { ...userConfig.experimental, serverComponents: true },
+    port: options.port ?? userConfig.server?.port,
+    plugins: [
+      ...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");
+  return createServer(await createFarmRscViteConfig(userConfig, { ...options, command: "serve" }));
+}
+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-6ONBZGVH.cjs

@@ -0,0 +1,124 @@
+"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 _chunkB5BBTPJQcjs = require('./chunk-B5BBTPJQ.cjs');
+
+
+var _chunkCA7DNRHOcjs = require('./chunk-CA7DNRHO.cjs');
+
+// src/mcp-catalog.ts
+var CATALOGS = /* @__PURE__ */ Symbol.for("farm.mcp.catalogs");
+function catalogs() {
+  const state = globalThis;
+  return _nullishCoalesce(state[CATALOGS], () => ( (state[CATALOGS] = /* @__PURE__ */ new Map())));
+}
+function _listFarmMCPCatalogs() {
+  return [...catalogs().values()];
+}
+function _publishFarmMCPCatalog(server, tools, details) {
+  const entry = { server, tools, ...details ? { details } : {} };
+  catalogs().set(server.path, entry);
+  return () => {
+    if (catalogs().get(server.path) === entry) catalogs().delete(server.path);
+  };
+}
+var SERVERS = /* @__PURE__ */ Symbol.for("farm.mcp.servers");
+function registeredServers() {
+  const state = globalThis;
+  return _nullishCoalesce(state[SERVERS], () => ( (state[SERVERS] = /* @__PURE__ */ new Map())));
+}
+function _listFarmRegisteredMCPServers() {
+  return [...registeredServers().values()];
+}
+function registerFarmMCPServer(server) {
+  const entry = validateFarmMCPServerRegistration(server);
+  const key = _nullishCoalesce(entry.path, () => ( entry.url));
+  registeredServers().set(key, entry);
+  return () => {
+    if (registeredServers().get(key) === entry) registeredServers().delete(key);
+  };
+}
+function validateFarmMCPServerRegistration(server) {
+  if (!server || typeof server !== "object") {
+    throw new TypeError("registerFarmMCPServer expects a server object.");
+  }
+  const text = (key, required) => {
+    const value = server[key];
+    if (value === void 0 && !required) return void 0;
+    if (typeof value !== "string" || !value.trim()) {
+      throw new TypeError(`registerFarmMCPServer ${key} must be a non-empty string.`);
+    }
+    return value.trim();
+  };
+  const name = text("name", true);
+  const version = text("version", true);
+  const title = text("title", false);
+  const description = text("description", false);
+  const { path, url } = server;
+  if (path === void 0 === (url === void 0)) {
+    throw new TypeError("registerFarmMCPServer takes exactly one of path and url.");
+  }
+  let endpoint;
+  if (path !== void 0) {
+    if (typeof path !== "string" || !/^\/(?!\/)[^?#\\\s]*$/.test(path) || path.split("/").some((segment) => segment === "." || segment === "..")) {
+      throw new TypeError(
+        "registerFarmMCPServer path must be an absolute app path without a query, hash, or dot segments."
+      );
+    }
+    endpoint = { path: path.length > 1 ? path.replace(/\/+$/, "") : path };
+  } else {
+    let parsed;
+    try {
+      parsed = typeof url === "string" ? new URL(url) : void 0;
+    } catch (e) {
+      parsed = void 0;
+    }
+    if (!parsed || parsed.protocol !== "https:" && parsed.protocol !== "http:" || parsed.username || parsed.password || parsed.search || parsed.hash) {
+      throw new TypeError(
+        "registerFarmMCPServer url must be an absolute http(s) URL without credentials, a query, or a hash."
+      );
+    }
+    endpoint = { url: `${parsed.origin}${parsed.pathname.replace(/\/+$/, "")}` };
+  }
+  const { protocolVersions } = server;
+  if (protocolVersions !== void 0 && (!Array.isArray(protocolVersions) || protocolVersions.some((version2) => typeof version2 !== "string" || !version2.trim()))) {
+    throw new TypeError("registerFarmMCPServer protocolVersions must be non-empty strings.");
+  }
+  return Object.freeze({
+    name,
+    version,
+    ...title ? { title } : {},
+    ...description ? { description } : {},
+    ..._optionalChain([protocolVersions, 'optionalAccess', _ => _.length]) ? { protocolVersions: Object.freeze([...protocolVersions]) } : {},
+    ...endpoint
+  });
+}
+function _findFarmMCPEndpointTool(method, pathname, serverBasePath) {
+  const upperMethod = method.toUpperCase();
+  for (const { server, tools } of catalogs().values()) {
+    const routes = /* @__PURE__ */ new Map();
+    for (const tool of tools) {
+      if (tool.kind === "endpoint" && tool.method === upperMethod) {
+        routes.set(tool.path, { path: tool.path, name: tool.name });
+      }
+    }
+    if (routes.size === 0) continue;
+    const canonical = serverBasePath ? _chunkB5BBTPJQcjs.resolveFarmAPICanonicalPathname.call(void 0, pathname, serverBasePath) : pathname;
+    const match = _chunkCA7DNRHOcjs.matchAPIRoute.call(void 0, routes, canonical);
+    if (match) {
+      return {
+        name: match.route.name,
+        endpoint: _chunkB5BBTPJQcjs.resolveFarmAPIServerRoutePath.call(void 0, server.path, serverBasePath)
+      };
+    }
+  }
+  return void 0;
+}
+
+
+
+
+
+
+
+exports._listFarmMCPCatalogs = _listFarmMCPCatalogs; exports._publishFarmMCPCatalog = _publishFarmMCPCatalog; exports._listFarmRegisteredMCPServers = _listFarmRegisteredMCPServers; exports.registerFarmMCPServer = registerFarmMCPServer; exports._findFarmMCPEndpointTool = _findFarmMCPEndpointTool;

package/dist/chunk-6XFGJBYX.cjs

@@ -0,0 +1,78 @@
+"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; }// src/dev-module.ts
+var failedModules = /* @__PURE__ */ new WeakMap();
+var FarmDevEnvironmentError = class extends Error {
+};
+async function loadFarmDevModule(server, id, environmentName = "ssr") {
+  const environment = server.environments[environmentName];
+  const runner = _optionalChain([environment, 'optionalAccess', _ => _.runner]);
+  if (!environment || !runner || typeof runner.import !== "function") {
+    throw new FarmDevEnvironmentError(
+      `[Farm.js] Cannot load ${JSON.stringify(id)}: the "${environmentName}" development environment must provide a module runner. Remote runtimes require a request/response adapter.`
+    );
+  }
+  try {
+    return await runner.import(id);
+  } catch (error) {
+    const failures = _nullishCoalesce(failedModules.get(environment), () => ( /* @__PURE__ */ new Map()));
+    failedModules.set(environment, failures);
+    await Promise.all(
+      [..._nullishCoalesce(_optionalChain([runner, 'access', _2 => _2.evaluatedModules, 'optionalAccess', _3 => _3.idToModuleMap, 'access', _4 => _4.values, 'call', _5 => _5()]), () => ( []))].filter((module) => module.evaluated && module.promise).map(async (module) => {
+        try {
+          await module.promise;
+        } catch (e) {
+          failures.set(module.id, module.promise);
+        }
+      })
+    );
+    throw error;
+  }
+}
+function invalidateFarmDevDependents(server, file, targets, environmentName = "ssr") {
+  const environment = server.environments[environmentName];
+  const graph = _optionalChain([environment, 'optionalAccess', _6 => _6.moduleGraph]);
+  if (!graph || targets.size === 0) return [];
+  const posix = (filePath) => filePath.replace(/\\/g, "/");
+  const byFile = new Map([...targets].map((target) => [posix(target), target]));
+  const reached = /* @__PURE__ */ new Set();
+  const seen = /* @__PURE__ */ new Set();
+  const queue = [..._nullishCoalesce(graph.getModulesByFile(posix(file)), () => ( []))];
+  while (queue.length > 0) {
+    const node = queue.pop();
+    if (seen.has(node)) continue;
+    seen.add(node);
+    const target = node.file ? byFile.get(posix(node.file)) : void 0;
+    if (target) reached.add(target);
+    queue.push(...node.importers);
+  }
+  if (reached.size === 0) return [];
+  const evaluatedModules = _optionalChain([environment, 'access', _7 => _7.runner, 'optionalAccess', _8 => _8.evaluatedModules]);
+  for (const node of seen) {
+    graph.invalidateModule(node);
+    const evaluated = node.id ? _optionalChain([evaluatedModules, 'optionalAccess', _9 => _9.getModuleById, 'call', _10 => _10(node.id)]) : void 0;
+    if (evaluated) evaluatedModules.invalidateModule(evaluated);
+  }
+  return [...reached];
+}
+function invalidateFailedFarmDevModules(server) {
+  for (const entry of Object.values(server.environments)) {
+    const environment = entry;
+    const failures = failedModules.get(environment);
+    if (!_optionalChain([failures, 'optionalAccess', _11 => _11.size])) continue;
+    const runner = environment.runner;
+    for (const [id, failed] of failures) {
+      const evaluated = runner.evaluatedModules.getModuleById(id);
+      if (_optionalChain([evaluated, 'optionalAccess', _12 => _12.promise]) !== failed) continue;
+      const transformed = environment.moduleGraph.getModuleById(id);
+      if (transformed) environment.moduleGraph.invalidateModule(transformed);
+      if (evaluated) runner.evaluatedModules.invalidateModule(evaluated);
+    }
+    failures.clear();
+  }
+}
+
+
+
+
+
+
+exports.FarmDevEnvironmentError = FarmDevEnvironmentError; exports.loadFarmDevModule = loadFarmDevModule; exports.invalidateFarmDevDependents = invalidateFarmDevDependents; exports.invalidateFailedFarmDevModules = invalidateFailedFarmDevModules;

package/dist/chunk-6XQSPIN6.cjs

@@ -0,0 +1,155 @@
+"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 _chunk6CTFVBATcjs = require('./chunk-6CTFVBAT.cjs');
+
+
+
+var _chunkOWQV6MLMcjs = require('./chunk-OWQV6MLM.cjs');
+
+
+var _chunkYTVSWXEZcjs = require('./chunk-YTVSWXEZ.cjs');
+
+// src/plugins/route-pattern.ts
+function validateConfigRouteSource(source, field = "Config route source") {
+  if (typeof source !== "string" || source.length === 0) {
+    throw new TypeError(`${field} must be a non-empty pathname pattern.`);
+  }
+  if (source.trim() !== source) {
+    throw new Error(`${field} cannot contain leading or trailing whitespace.`);
+  }
+  if (!source.startsWith("/")) {
+    throw new Error(`${field} must start with "/".`);
+  }
+  if (source.includes("?") || source.includes("#")) {
+    throw new Error(`${field} must be a pathname without a query string or hash.`);
+  }
+  if (source.includes("\\") || Array.from(source).some((character) => {
+    const code = character.charCodeAt(0);
+    return code <= 31 || code >= 127 && code <= 159;
+  })) {
+    throw new Error(`${field} cannot contain backslashes or control characters.`);
+  }
+  _chunkYTVSWXEZcjs.assertBrowserStableRoutePath.call(void 0, source);
+  return source;
+}
+function resolveConfigRoutePathname(pathname, i18n) {
+  const localizedPathname = _optionalChain([i18n, 'optionalAccess', _ => _.enabled]) ? _chunkOWQV6MLMcjs.resolveFarmLocalePath.call(void 0, pathname, i18n) : { pathname };
+  return {
+    pathname: normalizeConfigRoutePathname(_chunk6CTFVBATcjs.canonicalizeRequestPathname.call(void 0, localizedPathname.pathname)),
+    ..._optionalChain([i18n, 'optionalAccess', _2 => _2.enabled]) && "locale" in localizedPathname ? { locale: localizedPathname.locale } : {}
+  };
+}
+function normalizeConfigRoutePathname(pathname) {
+  if (!pathname || pathname === "/") return "/";
+  return pathname.endsWith("/") ? pathname.replace(/\/+$/, "") || "/" : pathname;
+}
+function localizeConfigRouteDestination(destination, locale, i18n) {
+  return locale && _optionalChain([i18n, 'optionalAccess', _3 => _3.enabled]) ? _chunkOWQV6MLMcjs.localizeFarmHref.call(void 0, destination, locale, i18n) : destination;
+}
+function appendCatchAll(pattern) {
+  return pattern.endsWith("/") ? `${pattern.slice(0, -1)}(?:/(.*))?` : `${pattern}(.*)`;
+}
+function escapeRegexCharacter(character) {
+  return /[\\^$.*+?()[\]{}|]/.test(character) ? `\\${character}` : character;
+}
+function compileConfigRoutePattern(source) {
+  validateConfigRouteSource(source);
+  const tokens = [];
+  let pattern = "";
+  let captureIndex = 1;
+  for (let index = 0; index < source.length; ) {
+    const rest = source.slice(index);
+    const parameter = rest.match(/^:([A-Za-z0-9_]+)(\*)?/);
+    if (parameter) {
+      tokens.push({
+        kind: "param",
+        name: parameter[1],
+        captureIndex,
+        catchAll: parameter[2] === "*"
+      });
+      pattern = parameter[2] ? appendCatchAll(pattern) : `${pattern}([^/]+)`;
+      captureIndex += 1;
+      index += parameter[0].length;
+      continue;
+    }
+    if (source[index] === "*") {
+      tokens.push({ kind: "wildcard", captureIndex });
+      pattern = appendCatchAll(pattern);
+      captureIndex += 1;
+      index += 1;
+      continue;
+    }
+    pattern += escapeRegexCharacter(source[index]);
+    index += 1;
+  }
+  return { regex: new RegExp(`^${pattern}$`), tokens };
+}
+function interpolateConfigRouteDestination(destination, match, tokens) {
+  const namedCaptures = /* @__PURE__ */ new Map();
+  const wildcardCaptures = [];
+  const captures = /* @__PURE__ */ new Map();
+  for (const token of tokens) {
+    const value = normalizeConfigRouteCapture(
+      match[token.captureIndex] || "",
+      token.kind === "wildcard" || token.catchAll
+    );
+    captures.set(token.captureIndex, value);
+    if (token.kind === "param") {
+      namedCaptures.set(token.name, value);
+    } else {
+      wildcardCaptures.push(value);
+    }
+  }
+  let result = "";
+  let wildcardIndex = 0;
+  for (let index = 0; index < destination.length; ) {
+    const rest = destination.slice(index);
+    const parameter = rest.match(/^:([A-Za-z0-9_]+)(\*)?/);
+    if (parameter) {
+      const value = namedCaptures.get(parameter[1]);
+      result += value === void 0 ? parameter[0] : value;
+      index += parameter[0].length;
+      continue;
+    }
+    const capture = rest.match(/^\$(\d+)/);
+    if (capture) {
+      result += _nullishCoalesce(captures.get(Number(capture[1])), () => ( ""));
+      index += capture[0].length;
+      continue;
+    }
+    if (destination[index] === "*") {
+      result += wildcardCaptures[wildcardIndex] || "";
+      wildcardIndex += 1;
+      index += 1;
+      continue;
+    }
+    result += destination[index];
+    index += 1;
+  }
+  return result;
+}
+function normalizeConfigRouteCapture(value, catchAll) {
+  const segments = catchAll ? value.split("/").filter(Boolean) : [value];
+  return segments.map((segment) => encodeConfigRouteSegment(decodeConfigRouteSegment(segment))).join("/");
+}
+function decodeConfigRouteSegment(segment) {
+  try {
+    return decodeURIComponent(segment);
+  } catch (e) {
+    return segment;
+  }
+}
+function encodeConfigRouteSegment(segment) {
+  return encodeURIComponent(segment).replace(
+    /[!'()*]/g,
+    (character) => `%${character.charCodeAt(0).toString(16).toUpperCase()}`
+  );
+}
+
+
+
+
+
+
+
+exports.validateConfigRouteSource = validateConfigRouteSource; exports.resolveConfigRoutePathname = resolveConfigRoutePathname; exports.localizeConfigRouteDestination = localizeConfigRouteDestination; exports.compileConfigRoutePattern = compileConfigRoutePattern; exports.interpolateConfigRouteDestination = interpolateConfigRouteDestination;