@farm.js/core 0.1.60 → 0.1.61

package/dist/chunk-PNGWZFUQ.mjs

@@ -0,0 +1,39 @@
+import {
+  __name
+} from "./chunk-LPEX4YW6.mjs";
+
+// src/font.ts
+function defineLayoutFonts(fonts) {
+  return fonts;
+}
+__name(defineLayoutFonts, "defineLayoutFonts");
+function resolveFarmLayoutFonts(layouts) {
+  let resolved;
+  for (const layout of layouts) {
+    if (!layout.fonts) continue;
+    resolved = { ...resolved, ...layout.fonts };
+  }
+  return resolved;
+}
+__name(resolveFarmLayoutFonts, "resolveFarmLayoutFonts");
+function fontCompilerError(loader) {
+  throw new Error(
+    `[Farm fonts] ${loader}() must be called at module scope with static options and compiled by the Farm Vite plugin.`
+  );
+}
+__name(fontCompilerError, "fontCompilerError");
+function localFont(_options) {
+  return fontCompilerError("localFont");
+}
+__name(localFont, "localFont");
+function remoteFont(_options) {
+  return fontCompilerError("remoteFont");
+}
+__name(remoteFont, "remoteFont");
+
+export {
+  defineLayoutFonts,
+  resolveFarmLayoutFonts,
+  localFont,
+  remoteFont
+};

package/dist/chunk-PSV6XKPO.cjs

@@ -0,0 +1,220 @@
+"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 _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/renderer.ts
+var _fs = require('fs'); var _fs2 = _interopRequireDefault(_fs);
+var _module = require('module');
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var _url = require('url');
+var DEFAULT_RENDERER_CAPABILITIES = Object.freeze({
+  streaming: Object.freeze({ node: false, web: false }),
+  // Conservative default: assume a re-render rebuilds until a renderer states
+  // otherwise, so callers do not silently rely on reconciliation.
+  reconcilesRerenders: false,
+  functionComponents: false
+});
+function getFarmRendererCapabilities(renderer) {
+  const defaultStreaming = {
+    node: _nullishCoalesce(_optionalChain([renderer, 'optionalAccess', _ => _.capabilities, 'optionalAccess', _2 => _2.streaming, 'optionalAccess', _3 => _3.node]), () => ( DEFAULT_RENDERER_CAPABILITIES.streaming.node)),
+    web: _nullishCoalesce(_optionalChain([renderer, 'optionalAccess', _4 => _4.capabilities, 'optionalAccess', _5 => _5.streaming, 'optionalAccess', _6 => _6.web]), () => ( DEFAULT_RENDERER_CAPABILITIES.streaming.web))
+  };
+  const runtimes = Object.fromEntries(
+    ["node", "edge"].flatMap((runtime) => {
+      const override = _optionalChain([renderer, 'optionalAccess', _7 => _7.capabilities, 'optionalAccess', _8 => _8.streaming, 'optionalAccess', _9 => _9.runtimes, 'optionalAccess', _10 => _10[runtime]]);
+      if (!override) return [];
+      return [
+        [
+          runtime,
+          {
+            node: _nullishCoalesce(override.node, () => ( defaultStreaming.node)),
+            web: _nullishCoalesce(override.web, () => ( defaultStreaming.web))
+          }
+        ]
+      ];
+    })
+  );
+  return {
+    streaming: {
+      ...defaultStreaming,
+      ...Object.keys(runtimes).length > 0 ? { runtimes } : {}
+    },
+    reconcilesRerenders: _nullishCoalesce(_optionalChain([renderer, 'optionalAccess', _11 => _11.capabilities, 'optionalAccess', _12 => _12.reconcilesRerenders]), () => ( DEFAULT_RENDERER_CAPABILITIES.reconcilesRerenders)),
+    functionComponents: _nullishCoalesce(_optionalChain([renderer, 'optionalAccess', _13 => _13.capabilities, 'optionalAccess', _14 => _14.functionComponents]), () => ( DEFAULT_RENDERER_CAPABILITIES.functionComponents))
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getFarmRendererCapabilities, "getFarmRendererCapabilities");
+function getFarmRendererStreamingCapabilitiesForRuntime(renderer, runtime) {
+  const streaming = getFarmRendererCapabilities(renderer).streaming;
+  if (runtime === "unknown") return { node: streaming.node, web: streaming.web };
+  return _nullishCoalesce(_optionalChain([streaming, 'access', _15 => _15.runtimes, 'optionalAccess', _16 => _16[runtime]]), () => ( { node: streaming.node, web: streaming.web }));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getFarmRendererStreamingCapabilitiesForRuntime, "getFarmRendererStreamingCapabilitiesForRuntime");
+function assertFarmRendererStreamingRuntime(name, renderer, runtimeModule, runtime) {
+  const declared = getFarmRendererStreamingCapabilitiesForRuntime(renderer, runtime);
+  const runtimeDeclaration = _optionalChain([runtimeModule, 'access', _17 => _17.capabilities, 'optionalAccess', _18 => _18.streaming]);
+  if (runtimeDeclaration) {
+    const advertised = getFarmRendererStreamingCapabilitiesForRuntime(
+      { capabilities: { streaming: runtimeDeclaration } },
+      runtime
+    );
+    if (declared.node && !advertised.node || declared.web && !advertised.web) {
+      throw new Error(
+        `Renderer \`${name}\` server module advertises ${JSON.stringify(advertised)} streaming for the ${runtime} runtime, which does not satisfy its descriptor ${JSON.stringify(declared)}.`
+      );
+    }
+  }
+  if (declared.node && typeof runtimeModule.renderToPipeableStream !== "function") {
+    throw new Error(
+      `Renderer \`${name}\` advertises Node streaming for the ${runtime} runtime but its server module does not export renderToPipeableStream().`
+    );
+  }
+  if (declared.web && typeof runtimeModule.renderToReadableStream !== "function") {
+    throw new Error(
+      `Renderer \`${name}\` advertises Web streaming for the ${runtime} runtime but its server module does not export renderToReadableStream().`
+    );
+  }
+  return declared;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, assertFarmRendererStreamingRuntime, "assertFarmRendererStreamingRuntime");
+var FARM_COMPONENT_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx"];
+function resolveFarmComponentExtensions(extensions = []) {
+  return Array.from(
+    new Set(
+      [...FARM_COMPONENT_EXTENSIONS, ...extensions].map((extension) => {
+        const normalized = extension.trim().toLowerCase();
+        return normalized.startsWith(".") ? normalized : `.${normalized}`;
+      })
+    )
+  ).filter((extension) => extension.length > 1);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveFarmComponentExtensions, "resolveFarmComponentExtensions");
+function getFarmRendererComponentExtensions(renderer) {
+  return resolveFarmComponentExtensions(_optionalChain([renderer, 'optionalAccess', _19 => _19.componentExtensions]));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getFarmRendererComponentExtensions, "getFarmRendererComponentExtensions");
+var REACT_RENDERER = Object.freeze({
+  name: "react",
+  vite: "@farm.js/core/renderer/react/vite",
+  server: "@farm.js/core/renderer/react/server",
+  client: "@farm.js/core/renderer/react/client",
+  jsxImportSource: "react",
+  dedupe: ["react", "react-dom", "react/jsx-runtime", "react/jsx-dev-runtime"],
+  optimizeDeps: [
+    "react",
+    "react-dom",
+    "react-dom/client",
+    "react/jsx-runtime",
+    "react/jsx-dev-runtime"
+  ],
+  capabilities: {
+    streaming: {
+      node: true,
+      web: false,
+      runtimes: { edge: { node: false, web: true } }
+    },
+    reconcilesRerenders: true,
+    functionComponents: true
+  }
+});
+function defineRenderer(renderer) {
+  return renderer;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, defineRenderer, "defineRenderer");
+function resolveFarmRenderer(renderer) {
+  const resolved = renderer || REACT_RENDERER;
+  const fields = ["name", "vite", "server", "client"];
+  for (const field of fields) {
+    if (typeof resolved[field] !== "string" || resolved[field].trim().length === 0) {
+      throw new TypeError(`Farm renderer \`${field}\` must be a non-empty string.`);
+    }
+  }
+  if (resolved.appSetup !== void 0 && (typeof resolved.appSetup !== "string" || resolved.appSetup.trim().length === 0)) {
+    throw new TypeError("Farm renderer `appSetup` must be a non-empty module path.");
+  }
+  return {
+    ...resolved,
+    componentExtensions: [...resolved.componentExtensions || []],
+    dedupe: [...resolved.dedupe || []],
+    optimizeDeps: [...resolved.optimizeDeps || []],
+    buildConcurrency: resolved.buildConcurrency || "parallel",
+    capabilities: getFarmRendererCapabilities(resolved),
+    options: resolved.options ? { ...resolved.options } : void 0
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveFarmRenderer, "resolveFarmRenderer");
+async function readFarmRendererWebStream(stream) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let html = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    html += typeof value === "string" ? value : decoder.decode(value, { stream: true });
+  }
+  return html + decoder.decode();
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, readFarmRendererWebStream, "readFarmRendererWebStream");
+function isReactRenderer(renderer) {
+  return !renderer || renderer.name === "react";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isReactRenderer, "isReactRenderer");
+function resolveFarmRendererAppSetup(root, renderer) {
+  if (!renderer.appSetup) return null;
+  const filePath = _path2.default.resolve(root, renderer.appSetup);
+  if (!_fs2.default.existsSync(filePath)) {
+    throw new Error(`Renderer \`${renderer.name}\` app setup module was not found: ${filePath}`);
+  }
+  return filePath;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveFarmRendererAppSetup, "resolveFarmRendererAppSetup");
+function resolveFarmRendererModule(root, specifier) {
+  const requireFromApp = _module.createRequire.call(void 0, _path2.default.join(_path2.default.resolve(root), "package.json"));
+  return requireFromApp.resolve(specifier);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveFarmRendererModule, "resolveFarmRendererModule");
+function createFarmReactJsxPlugin() {
+  return {
+    name: "farm:react-jsx",
+    config(config) {
+      if (this && _optionalChain([this, 'access', _20 => _20.meta, 'optionalAccess', _21 => _21.rolldownVersion])) return;
+      if (config.esbuild === false || _optionalChain([config, 'access', _22 => _22.esbuild, 'optionalAccess', _23 => _23.jsx]) !== void 0) return;
+      return { esbuild: { jsx: "automatic" } };
+    }
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createFarmReactJsxPlugin, "createFarmReactJsxPlugin");
+async function loadFarmRendererVitePlugins(renderer, root, options = {}) {
+  if (renderer.vite === REACT_RENDERER.vite) return [createFarmReactJsxPlugin()];
+  const modulePath = resolveFarmRendererModule(root, renderer.vite);
+  const rendererModule = await import(_url.pathToFileURL.call(void 0, modulePath).href);
+  if (typeof rendererModule.createFarmRendererPlugin !== "function") {
+    throw new Error(
+      `Renderer \`${renderer.name}\` module ${renderer.vite} must export createFarmRendererPlugin().`
+    );
+  }
+  const created = await rendererModule.createFarmRendererPlugin({
+    ...options,
+    rendererOptions: renderer.options
+  });
+  if (!created) return [];
+  return Array.isArray(created) ? [...created] : [created];
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, loadFarmRendererVitePlugins, "loadFarmRendererVitePlugins");
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.getFarmRendererCapabilities = getFarmRendererCapabilities; exports.getFarmRendererStreamingCapabilitiesForRuntime = getFarmRendererStreamingCapabilitiesForRuntime; exports.assertFarmRendererStreamingRuntime = assertFarmRendererStreamingRuntime; exports.FARM_COMPONENT_EXTENSIONS = FARM_COMPONENT_EXTENSIONS; exports.resolveFarmComponentExtensions = resolveFarmComponentExtensions; exports.getFarmRendererComponentExtensions = getFarmRendererComponentExtensions; exports.REACT_RENDERER = REACT_RENDERER; exports.defineRenderer = defineRenderer; exports.resolveFarmRenderer = resolveFarmRenderer; exports.readFarmRendererWebStream = readFarmRendererWebStream; exports.isReactRenderer = isReactRenderer; exports.resolveFarmRendererAppSetup = resolveFarmRendererAppSetup; exports.resolveFarmRendererModule = resolveFarmRendererModule; exports.loadFarmRendererVitePlugins = loadFarmRendererVitePlugins;

package/dist/chunk-PTZ2TVNE.cjs

@@ -0,0 +1,178 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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 _chunk4WQ6PGSJcjs = require('./chunk-4WQ6PGSJ.cjs');
+
+
+
+var _chunkEUV4YR3Vcjs = require('./chunk-EUV4YR3V.cjs');
+
+
+
+var _chunk75RZHGLScjs = require('./chunk-75RZHGLS.cjs');
+
+
+
+var _chunkI57LW5VZcjs = require('./chunk-I57LW5VZ.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/agent-mcp.ts
+var FARM_DEFAULT_MCP_PATH = "/mcp";
+var FARM_DEFAULT_MCP_PROTOCOL_VERSIONS = [
+  "2025-11-25",
+  "2025-06-18",
+  "2025-03-26",
+  "2024-11-05"
+];
+var FARM_DEFAULT_MCP_DESCRIPTION = "Read-only access to this site's public pages: list, search, and read them as Markdown.";
+var READ_ONLY = {
+  readOnlyHint: true,
+  destructiveHint: false,
+  idempotentHint: true,
+  openWorldHint: false
+};
+var PAGE_SCHEMA = {
+  type: "object",
+  properties: {
+    path: { type: "string", description: `The page's path, such as "/about".` },
+    title: { type: "string" },
+    url: { type: "string", description: "The page's absolute URL." },
+    description: { type: "string" }
+  },
+  required: ["path", "title", "url"]
+};
+var PAGES_OUTPUT_SCHEMA = {
+  type: "object",
+  properties: { pages: { type: "array", items: PAGE_SCHEMA } },
+  required: ["pages"]
+};
+var FARM_DEFAULT_MCP_TOOLS = [
+  {
+    name: "list_pages",
+    title: "List pages",
+    description: "List this site's public pages with each page's path, title, URL, and description. Pass a page's path to read_page to read it as Markdown.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    outputSchema: PAGES_OUTPUT_SCHEMA,
+    annotations: READ_ONLY
+  },
+  {
+    name: "search_pages",
+    title: "Search pages",
+    description: "Search this site's public pages by title, description, and path. Every word of the query must match. Returns the matching pages, best match first.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          minLength: 1,
+          maxLength: 200,
+          description: 'Words to look for, such as "pricing" or "getting started".'
+        },
+        limit: {
+          type: "integer",
+          minimum: 1,
+          maximum: 50,
+          default: 10,
+          description: "The most pages to return."
+        }
+      },
+      required: ["query"],
+      additionalProperties: false
+    },
+    outputSchema: PAGES_OUTPUT_SCHEMA,
+    annotations: READ_ONLY
+  },
+  {
+    name: "read_page",
+    title: "Read a page",
+    description: `Read one of this site's public pages as Markdown. Takes a path from list_pages or search_pages, such as "/" or "/about".`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          minLength: 1,
+          maxLength: 2048,
+          description: `The page's path, such as "/about", or its full URL on this site.`
+        }
+      },
+      required: ["path"],
+      additionalProperties: false
+    },
+    annotations: READ_ONLY
+  }
+];
+function collectFarmDefaultMCPPages(sources, options) {
+  const readable = [];
+  for (const source of sources) {
+    const module = isRecord(source.module) ? source.module : void 0;
+    if (_optionalChain([module, 'optionalAccess', _ => _.__farmRouteGuard])) continue;
+    if (!_chunkEUV4YR3Vcjs.isFarmMarkdownMirrorExposed.call(void 0, options.markdown, source.pattern)) continue;
+    readable.push({ pattern: source.pattern, metadata: _optionalChain([module, 'optionalAccess', _2 => _2.metadata]) });
+  }
+  return _chunk4WQ6PGSJcjs.collectFarmLlmsTxtPages.call(void 0, readable, {
+    origin: options.origin,
+    basePath: options.basePath,
+    markdown: options.markdown
+  }).map((page) => ({
+    path: page.path,
+    title: page.title,
+    url: `${options.origin}${_chunkI57LW5VZcjs.applyFarmBasePath.call(void 0, page.path, options.basePath)}`,
+    ...page.description ? { description: page.description } : {},
+    markdownUrl: `${options.origin}${_chunkI57LW5VZcjs.applyFarmBasePath.call(void 0, 
+      _chunkEUV4YR3Vcjs.getFarmMarkdownMirrorPath.call(void 0, page.path),
+      options.basePath
+    )}`
+  }));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, collectFarmDefaultMCPPages, "collectFarmDefaultMCPPages");
+function createFarmDefaultMCPServer(app, farmVersion) {
+  const name = typeof _optionalChain([app, 'optionalAccess', _3 => _3.name]) === "string" && app.name.trim() ? app.name.trim() : "farm-app";
+  const version = typeof _optionalChain([app, 'optionalAccess', _4 => _4.version]) === "string" && app.version.trim() ? app.version.trim() : farmVersion;
+  return {
+    name,
+    version,
+    description: FARM_DEFAULT_MCP_DESCRIPTION,
+    protocolVersions: [...FARM_DEFAULT_MCP_PROTOCOL_VERSIONS],
+    path: FARM_DEFAULT_MCP_PATH
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createFarmDefaultMCPServer, "createFarmDefaultMCPServer");
+function resolveFarmDefaultMCPServer(server) {
+  if (!server) return void 0;
+  if (_chunk75RZHGLScjs._listFarmMCPCatalogs.call(void 0, ).length > 0 || _chunk75RZHGLScjs._listFarmRegisteredMCPServers.call(void 0, ).length > 0) {
+    return void 0;
+  }
+  return server;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveFarmDefaultMCPServer, "resolveFarmDefaultMCPServer");
+function isFarmDefaultMCPPathname(pathname, basePath) {
+  const path = _chunkI57LW5VZcjs.stripFarmBasePath.call(void 0, pathname, basePath);
+  return path === FARM_DEFAULT_MCP_PATH || path === `${FARM_DEFAULT_MCP_PATH}/`;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isFarmDefaultMCPPathname, "isFarmDefaultMCPPathname");
+function farmConfigMountsMCP(config) {
+  const { mcp } = config;
+  if (isRecord(mcp) && mcp.enabled !== false) return true;
+  return Boolean(
+    _optionalChain([config, 'access', _5 => _5.plugins, 'optionalAccess', _6 => _6.some, 'call', _7 => _7((plugin) => isRecord(plugin) && plugin.name === "farm:api-mcp")])
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, farmConfigMountsMCP, "farmConfigMountsMCP");
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isRecord, "isRecord");
+
+
+
+
+
+
+
+
+
+
+
+exports.FARM_DEFAULT_MCP_PATH = FARM_DEFAULT_MCP_PATH; exports.FARM_DEFAULT_MCP_PROTOCOL_VERSIONS = FARM_DEFAULT_MCP_PROTOCOL_VERSIONS; exports.FARM_DEFAULT_MCP_DESCRIPTION = FARM_DEFAULT_MCP_DESCRIPTION; exports.FARM_DEFAULT_MCP_TOOLS = FARM_DEFAULT_MCP_TOOLS; exports.collectFarmDefaultMCPPages = collectFarmDefaultMCPPages; exports.createFarmDefaultMCPServer = createFarmDefaultMCPServer; exports.resolveFarmDefaultMCPServer = resolveFarmDefaultMCPServer; exports.isFarmDefaultMCPPathname = isFarmDefaultMCPPathname; exports.farmConfigMountsMCP = farmConfigMountsMCP;