@farm.js/core 0.1.47 → 0.1.49

package/dist/chunk-L5JDKFMQ.cjs

@@ -0,0 +1,44 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+
+var _chunkRI3EVPKDcjs = require('./chunk-RI3EVPKD.cjs');
+
+// src/i18n/client-runtime.ts
+var _intlmessageformat = require('intl-messageformat'); var _intlmessageformat2 = _interopRequireDefault(_intlmessageformat);
+var readOwnMessage = (messages, key) => Object.prototype.hasOwnProperty.call(messages, key) ? messages[key] : void 0;
+var translate = (key, values, rich = false) => {
+  const snapshot = requireSnapshot();
+  const message = readOwnMessage(snapshot.messages, key);
+  if (message === void 0) return key;
+  const cacheKey = `${snapshot.locale}\0${key}\0${message}`;
+  let formatter = _chunkRI3EVPKDcjs.compiledFarmI18nMessages.get(cacheKey);
+  if (!formatter) {
+    formatter = new (0, _intlmessageformat2.default)(message, snapshot.locale);
+    _chunkRI3EVPKDcjs.compiledFarmI18nMessages.set(cacheKey, formatter);
+  }
+  const result = formatter.format(values);
+  if (rich) return Array.isArray(result) && result.length === 1 ? result[0] : result;
+  if (Array.isArray(result) && result.some((part) => typeof part !== "string")) {
+    throw new Error(`Farm i18n message "${key}" contains rich content. Render it with t.rich().`);
+  }
+  return Array.isArray(result) ? result.join("") : String(result);
+};
+var t = ((key, values) => translate(key, values));
+t.rich = (key, values) => translate(key, values, true);
+t.raw = (key) => _nullishCoalesce(readOwnMessage(requireSnapshot().messages, key), () => ( key));
+t.has = (key) => Object.prototype.hasOwnProperty.call(requireSnapshot().messages, key);
+function createFarmClientTranslator() {
+  return ((key, ...args) => t(key, ...args));
+}
+function requireSnapshot() {
+  const snapshot = _chunkRI3EVPKDcjs.getFarmI18nClientState.call(void 0, );
+  if (!snapshot) {
+    throw new Error("Farm i18n is not configured or has not been hydrated.");
+  }
+  return snapshot;
+}
+
+
+
+
+exports.t = t; exports.createFarmClientTranslator = createFarmClientTranslator;

package/dist/chunk-L6QDME5Z.cjs

@@ -0,0 +1,36 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunkJ2ZEVDEKcjs = require('./chunk-J2ZEVDEK.cjs');
+
+// src/middleware/path.ts
+function appendMiddlewareRoutePath(routePath, directoryName) {
+  const marker = _chunkJ2ZEVDEKcjs.parseInterceptionMarker.call(void 0, directoryName);
+  if (marker) {
+    const owner = routePath.split("/").filter(Boolean);
+    const parts = [
+      ...marker.root ? [] : owner.slice(0, Math.max(0, owner.length - marker.up)),
+      ...marker.remainder ? [marker.remainder] : []
+    ];
+    return `/${parts.join("/")}`;
+  }
+  if (directoryName.startsWith("(") && directoryName.endsWith(")") || _chunkJ2ZEVDEKcjs.isRouteSlotSegment.call(void 0, directoryName)) {
+    return routePath;
+  }
+  return routePath === "/" ? `/${directoryName}` : `${routePath}/${directoryName}`;
+}
+function appendMiddlewareDirectory(directory, directoryName) {
+  return directory === "" ? directoryName : `${directory}/${directoryName}`;
+}
+function countSegments(value) {
+  return value.split("/").filter(Boolean).length;
+}
+function compareMiddlewareRouteLocations(left, right) {
+  return countSegments(left.path) - countSegments(right.path) || left.path.localeCompare(right.path) || countSegments(left.directory) - countSegments(right.directory) || left.directory.localeCompare(right.directory);
+}
+
+
+
+
+
+exports.appendMiddlewareRoutePath = appendMiddlewareRoutePath; exports.appendMiddlewareDirectory = appendMiddlewareDirectory; exports.compareMiddlewareRouteLocations = compareMiddlewareRouteLocations;

package/dist/chunk-LAZK6UV7.mjs

@@ -0,0 +1,341 @@
+import {
+  FARM_INTERNAL_READ_HEADER,
+  getFarmMarkdownMirrorPath,
+  isFarmMarkdownMirrorExposed,
+  matchesFarmMarkdownRoutePattern
+} from "./chunk-N77JBPLC.mjs";
+import {
+  applyFarmBasePath
+} from "./chunk-SF3JB56B.mjs";
+
+// src/llms-txt.ts
+function resolveFarmLlmsTxtConfig(input) {
+  if (!input) return { enabled: false, include: [], exclude: [], full: false };
+  if (input === true) return { enabled: true, include: [], exclude: [], full: true };
+  if (typeof input !== "object") {
+    throw new TypeError("agent.llmsTxt must be true, false, or an options object.");
+  }
+  if (input.enabled === false) return { enabled: false, include: [], exclude: [], full: false };
+  for (const key of ["title", "summary", "details"]) {
+    if (input[key] !== void 0 && typeof input[key] !== "string") {
+      throw new TypeError(`agent.llmsTxt.${key} must be a string.`);
+    }
+  }
+  if (input.full !== void 0 && typeof input.full !== "boolean") {
+    throw new TypeError("agent.llmsTxt.full must be a boolean.");
+  }
+  if (input.revalidate !== void 0 && (typeof input.revalidate !== "number" || !Number.isFinite(input.revalidate) || input.revalidate < 0)) {
+    throw new TypeError("agent.llmsTxt.revalidate must be a number of seconds.");
+  }
+  return {
+    enabled: true,
+    ...input.title ? { title: input.title } : {},
+    ...input.summary ? { summary: input.summary } : {},
+    ...input.details ? { details: input.details } : {},
+    include: resolveRoutePatterns(input.include, "include"),
+    exclude: resolveRoutePatterns(input.exclude, "exclude"),
+    full: input.full !== false,
+    ...input.revalidate !== void 0 ? { revalidate: input.revalidate } : {}
+  };
+}
+function resolveRoutePatterns(value, key) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value)) {
+    throw new TypeError(`agent.llmsTxt.${key} must be an array of route patterns.`);
+  }
+  return value.map((pattern, index) => {
+    if (typeof pattern !== "string" || !pattern.startsWith("/")) {
+      throw new TypeError(
+        `agent.llmsTxt.${key}[${index}] must be a route pattern starting with "/", such as "/docs/[...slug]".`
+      );
+    }
+    return pattern;
+  });
+}
+function collectFarmLlmsTxtPages(sources, options) {
+  const include = options.include ?? [];
+  const exclude = options.exclude ?? [];
+  const pages = /* @__PURE__ */ new Map();
+  for (const source of sources) {
+    const path = source.pattern;
+    if (path.includes("[") || pages.has(path)) continue;
+    if (include.length && !include.some((pattern) => matchesFarmMarkdownRoutePattern(pattern, path))) {
+      continue;
+    }
+    if (exclude.some((pattern) => matchesFarmMarkdownRoutePattern(pattern, path))) continue;
+    if (isFarmMetadataNoIndex(source.metadata)) continue;
+    const target = isFarmMarkdownMirrorExposed(options.markdown, path) ? getFarmMarkdownMirrorPath(path) : path;
+    const description = readMetadataString(source.metadata, "description");
+    pages.set(path, {
+      path,
+      title: readMetadataTitle(source.metadata) ?? fallbackPageTitle(path),
+      url: `${options.origin}${applyFarmBasePath(target, options.basePath)}`,
+      ...description ? { description } : {}
+    });
+  }
+  return [...pages.values()].sort((left, right) => left.path.localeCompare(right.path));
+}
+function isFarmMetadataNoIndex(metadata) {
+  if (!metadata || typeof metadata !== "object") return false;
+  const robots = metadata.robots;
+  if (typeof robots === "string") {
+    return robots.split(",").map((directive) => directive.trim().toLowerCase()).some((directive) => directive === "noindex" || directive === "none");
+  }
+  return Boolean(
+    robots && typeof robots === "object" && robots.index === false
+  );
+}
+function createFarmDefaultLlmsTxt(options) {
+  const { config, pages } = options;
+  const mcp = options.mcp ?? [];
+  const summary = config.summary ?? readMetadataString(options.rootMetadata, "description");
+  return {
+    title: config.title ?? readMetadataTitle(options.rootMetadata) ?? pages.find((page) => page.path === "/")?.title ?? new URL(options.origin).host,
+    ...summary ? { summary } : {},
+    ...config.details ? { details: config.details } : {},
+    sections: [
+      ...pages.length ? [
+        {
+          title: "Pages",
+          links: pages.map(({ title, url, description }) => ({
+            title,
+            url,
+            ...description ? { description } : {}
+          }))
+        }
+      ] : [],
+      ...mcp.length ? [{ title: "MCP", links: mcp }] : []
+    ]
+  };
+}
+function serializeFarmLlmsTxt(value) {
+  if (typeof value === "string") {
+    if (!value.trim()) throw new TypeError("llms.ts returned an empty llms.txt");
+    return value.endsWith("\n") ? value : `${value}
+`;
+  }
+  if (!isRecord(value)) {
+    throw new TypeError("llms.ts must return llms.txt text, an llms.txt object, or a Response");
+  }
+  const title = requireText(value.title, "llms.ts must return a non-empty title");
+  const summary = optionalText(value.summary, "llms.ts summary must be a string");
+  const details = optionalText(value.details, "llms.ts details must be a string");
+  if (value.sections !== void 0 && !Array.isArray(value.sections)) {
+    throw new TypeError("llms.ts sections must be an array");
+  }
+  const blocks = [`# ${toSingleLine(title)}`];
+  if (summary?.trim()) blocks.push(`> ${toSingleLine(summary)}`);
+  if (details?.trim()) blocks.push(details.trim());
+  for (const [sectionIndex, section] of (value.sections ?? []).entries()) {
+    if (!isRecord(section)) {
+      throw new TypeError(`llms.ts section ${sectionIndex} must be an object`);
+    }
+    const sectionTitle = requireText(
+      section.title,
+      `llms.ts section ${sectionIndex} must include a non-empty title`
+    );
+    if (!Array.isArray(section.links)) {
+      throw new TypeError(`llms.ts section "${sectionTitle}" must include a links array`);
+    }
+    const links = section.links.map((link, linkIndex) => {
+      const where = `llms.ts section "${sectionTitle}" link ${linkIndex}`;
+      if (!isRecord(link)) throw new TypeError(`${where} must be an object`);
+      const linkTitle = requireText(link.title, `${where} must include a non-empty title`);
+      const url = requireText(link.url, `${where} must include a non-empty url`);
+      const description = optionalText(link.description, `${where} description must be a string`);
+      return `- [${escapeLinkText(linkTitle)}](${escapeLinkUrl(url)})${description?.trim() ? `: ${toSingleLine(description)}` : ""}`;
+    });
+    blocks.push(`## ${toSingleLine(sectionTitle)}`, links.join("\n"));
+  }
+  return `${blocks.filter(Boolean).join("\n\n")}
+`;
+}
+function createFarmLlmsMarkdownReader(fetchMarkdown) {
+  return async (url) => {
+    try {
+      const response = await fetchMarkdown(
+        new Request(url, {
+          headers: { accept: "text/markdown", [FARM_INTERNAL_READ_HEADER]: "llms-full" }
+        })
+      );
+      const type = response.headers.get("content-type") ?? "";
+      if (!response.ok || !type.toLowerCase().startsWith("text/markdown")) {
+        await response.body?.cancel();
+        return null;
+      }
+      return await response.text();
+    } catch {
+      return null;
+    }
+  };
+}
+var FARM_LLMS_FULL_PAGE_TIMEOUT_MS = 3e4;
+var LLMS_PAGE_TIMED_OUT = /* @__PURE__ */ Symbol("farm.llms.pageTimedOut");
+async function renderFarmLlmsFullTxt(value, options) {
+  const index = serializeFarmLlmsTxt(value);
+  if (typeof value === "string") return index;
+  const llms = value;
+  const links = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const section of llms.sections ?? []) {
+    for (const link of section.links) {
+      if (seen.has(link.url)) continue;
+      seen.add(link.url);
+      links.push(link);
+    }
+  }
+  const pageTimeout = options.pageTimeout ?? FARM_LLMS_FULL_PAGE_TIMEOUT_MS;
+  const readWithinTimeout = async (url) => {
+    let timer;
+    const timedOut = new Promise((resolve) => {
+      timer = setTimeout(resolve, pageTimeout, LLMS_PAGE_TIMED_OUT);
+    });
+    try {
+      const content = await Promise.race([options.readMarkdown(url), timedOut]);
+      if (content !== LLMS_PAGE_TIMED_OUT) return content;
+      options.onIncomplete?.();
+      return null;
+    } finally {
+      clearTimeout(timer);
+    }
+  };
+  const contents = await mapWithConcurrency(
+    links,
+    options.concurrency ?? 4,
+    (link) => shouldInlineLlmsLink(link.url, options.origin) ? readWithinTimeout(link.url) : null
+  );
+  const blocks = [`# ${toSingleLine(llms.title)}`];
+  if (llms.summary?.trim()) blocks.push(`> ${toSingleLine(llms.summary)}`);
+  if (llms.details?.trim()) blocks.push(llms.details.trim());
+  const pages = links.map((link, index2) => {
+    const parts = [`## ${toSingleLine(link.title)}`, `URL: ${escapeLinkUrl(link.url)}`];
+    if (link.description?.trim()) parts.push(toSingleLine(link.description));
+    const content = stripFrontmatter(contents[index2] ?? "").trim();
+    if (content) parts.push(content);
+    return parts.join("\n\n");
+  });
+  if (pages.length) blocks.push(pages.join("\n\n---\n\n"));
+  return `${blocks.join("\n\n")}
+`;
+}
+function createFarmLlmsFullRenderer(options = {}) {
+  const now = options.now ?? Date.now;
+  const ttl = (options.revalidate ?? 0) * 1e3;
+  const maxEntries = options.maxEntries ?? 16;
+  const entries = /* @__PURE__ */ new Map();
+  let queue = Promise.resolve();
+  const settle = (body, complete, onSettled) => onSettled ? body.then((value) => (onSettled(complete()), value)) : body;
+  return (origin, render, onSettled) => {
+    const entry = entries.get(origin);
+    if (entry && entry.expires > now()) return settle(entry.body, entry.complete, onSettled);
+    entries.delete(origin);
+    let complete = true;
+    const body = queue.then(
+      () => render({
+        incomplete: () => {
+          complete = false;
+        }
+      })
+    );
+    queue = body.catch(() => {
+    });
+    const pending = { body, expires: Number.POSITIVE_INFINITY, complete: () => complete };
+    entries.set(origin, pending);
+    if (entries.size > maxEntries) entries.delete(entries.keys().next().value);
+    body.then(
+      () => {
+        if (entries.get(origin) !== pending) return;
+        if (ttl > 0 && complete) pending.expires = now() + ttl;
+        else entries.delete(origin);
+      },
+      () => {
+        if (entries.get(origin) === pending) entries.delete(origin);
+      }
+    );
+    return settle(body, pending.complete, onSettled);
+  };
+}
+function stripFrontmatter(markdown) {
+  const match = /^\uFEFF?---\r?\n[\s\S]*?\r?\n---[ \t]*(?:\r?\n|$)/.exec(markdown);
+  return match ? markdown.slice(match[0].length) : markdown;
+}
+function shouldInlineLlmsLink(url, origin) {
+  let target;
+  try {
+    target = new URL(url, origin);
+  } catch {
+    return false;
+  }
+  return target.origin === origin && !/\/llms(-full)?\.txt$/.test(target.pathname);
+}
+async function mapWithConcurrency(items, limit, run) {
+  const results = [];
+  let next = 0;
+  const worker = async () => {
+    while (next < items.length) {
+      const index = next++;
+      results[index] = await run(items[index]);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(Math.max(limit, 1), items.length) }, worker));
+  return results;
+}
+function readMetadataTitle(metadata) {
+  if (!isRecord(metadata)) return void 0;
+  const { title } = metadata;
+  if (typeof title === "string") return title.trim() || void 0;
+  if (isRecord(title)) {
+    for (const key of ["absolute", "default"]) {
+      const value = title[key];
+      if (typeof value === "string" && value.trim()) return value.trim();
+    }
+  }
+  return void 0;
+}
+function readMetadataString(metadata, key) {
+  if (!isRecord(metadata)) return void 0;
+  const value = metadata[key];
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function fallbackPageTitle(path) {
+  if (path === "/") return "Home";
+  const segments = path.split("/").filter(Boolean);
+  const segment = segments[segments.length - 1] ?? path;
+  const words = segment.replace(/[-_]+/g, " ").trim();
+  return words ? words[0].toUpperCase() + words.slice(1) : path;
+}
+function toSingleLine(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function escapeLinkText(value) {
+  return toSingleLine(value).replace(/[\\[\]]/g, "\\$&");
+}
+function escapeLinkUrl(value) {
+  return value.trim().replace(
+    /[\s()<>]/g,
+    (character) => character === "(" ? "%28" : character === ")" ? "%29" : encodeURIComponent(character)
+  );
+}
+function requireText(value, message) {
+  if (typeof value !== "string" || !value.trim()) throw new TypeError(message);
+  return value;
+}
+function optionalText(value, message) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string") throw new TypeError(message);
+  return value;
+}
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
+export {
+  resolveFarmLlmsTxtConfig,
+  collectFarmLlmsTxtPages,
+  isFarmMetadataNoIndex,
+  createFarmDefaultLlmsTxt,
+  serializeFarmLlmsTxt,
+  createFarmLlmsMarkdownReader,
+  renderFarmLlmsFullTxt,
+  createFarmLlmsFullRenderer
+};

package/dist/chunk-LL7TDMOM.mjs

@@ -0,0 +1,222 @@
+// src/desktop/config.ts
+import { existsSync, readFileSync } from "fs";
+import * as path from "path";
+var FARM_PLATFORM_ENV = "FARM_PLATFORM";
+var FARM_DESKTOP_DEV_SESSION = /* @__PURE__ */ Symbol.for("@farm.js/core/desktop-dev-session");
+function setFarmDesktopDevSession(session) {
+  const store = globalThis;
+  if (session) store[FARM_DESKTOP_DEV_SESSION] = session;
+  else delete store[FARM_DESKTOP_DEV_SESSION];
+}
+function resolveFarmPlatform(env = process.env) {
+  return env[FARM_PLATFORM_ENV] === "desktop" ? "desktop" : "web";
+}
+var DESKTOP_KEYS = /* @__PURE__ */ new Set(["name", "id", "version", "icon", "window", "shell"]);
+var WINDOW_KEYS = /* @__PURE__ */ new Set(["width", "height", "title"]);
+var APP_ID = /^[A-Za-z][A-Za-z0-9-]*(?:\.[A-Za-z0-9][A-Za-z0-9-]*)+$/;
+var SHELL_NAME = /^[a-z][a-z0-9-]*$/;
+var SHELL_PACKAGE = /^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*(?:\/[a-z0-9][a-z0-9._-]*)*$/;
+var failPrefix = "desktop";
+function fail(message) {
+  throw new TypeError(`${failPrefix}: ${message}`);
+}
+function isPlainObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function checkKeys(value, allowed, where) {
+  for (const key of Object.keys(value)) {
+    if (!allowed.has(key)) {
+      fail(`unknown option ${where}${key}. Supported: ${[...allowed].join(", ")}.`);
+    }
+  }
+}
+function optionalString(value, key) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string" || !value.trim()) fail(`${key} must be a non-empty string.`);
+  return value.trim();
+}
+function optionalSize(value, key) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 100 || value > 16384) {
+    fail(`${key} must be a whole number of points between 100 and 16384.`);
+  }
+  return value;
+}
+function validateFarmDesktopConfig(input, context) {
+  failPrefix = context ? `desktop (os: ${context.os})` : "desktop";
+  if (input === void 0) return void 0;
+  if (!isPlainObject(input)) {
+    fail(
+      context ? 'the function must return an object, such as { name: "Notes" }.' : 'must be an object, such as { name: "Notes" }, or a function that returns one.'
+    );
+  }
+  checkKeys(input, DESKTOP_KEYS, "");
+  optionalString(input.name, "name");
+  const id = optionalString(input.id, "id");
+  if (id !== void 0 && !APP_ID.test(id)) {
+    fail(`id must be a reverse-DNS identifier such as "com.example.notes", got "${id}".`);
+  }
+  optionalString(input.version, "version");
+  const icon = optionalString(input.icon, "icon");
+  if (icon !== void 0 && !/\.png$/i.test(icon)) {
+    fail(`icon must be a PNG file, such as "src/app-icon.png", got "${icon}".`);
+  }
+  if (input.window !== void 0) {
+    if (!isPlainObject(input.window)) fail("window must be an object, such as { width: 1024 }.");
+    checkKeys(input.window, WINDOW_KEYS, "window.");
+    optionalSize(input.window.width, "window.width");
+    optionalSize(input.window.height, "window.height");
+    optionalString(input.window.title, "window.title");
+  }
+  const shell = optionalString(input.shell, "shell");
+  if (shell !== void 0 && !SHELL_NAME.test(shell) && !shell.includes("/")) {
+    fail(`shell must be an adapter name such as "electrobun" or a package name, got "${shell}".`);
+  }
+  if (shell !== void 0 && shell.includes("/") && !SHELL_PACKAGE.test(shell)) {
+    fail(`shell "${shell}" is not a valid package name.`);
+  }
+  return input;
+}
+function readPackageJson(root) {
+  try {
+    const parsed = JSON.parse(readFileSync(path.join(root, "package.json"), "utf8"));
+    return isPlainObject(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function slug(value) {
+  return value.replace(/^@[^/]+\//, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "app";
+}
+function resolveFarmDesktopShellPackage(shell) {
+  return shell.includes("/") ? shell : `@farm.js/desktop/${shell}`;
+}
+function resolveFarmDesktopConfig(input, root, context) {
+  const config = validateFarmDesktopConfig(input, context) ?? {};
+  const pkg = readPackageJson(root);
+  const packageName = typeof pkg.productName === "string" && pkg.productName.trim() || typeof pkg.name === "string" && pkg.name.replace(/^@[^/]+\//, "").trim() || path.basename(root);
+  const name = config.name?.trim() || packageName || "Farm App";
+  const shell = config.shell?.trim() || "electrobun";
+  const icon = config.icon ? path.resolve(root, config.icon.trim()) : void 0;
+  if (icon && !existsSync(icon)) fail(`icon ${config.icon} was not found in ${root}.`);
+  return {
+    name,
+    id: config.id?.trim() || `local.farm.${slug(name)}`,
+    version: config.version?.trim() || typeof pkg.version === "string" && pkg.version.trim() || "0.0.0",
+    ...icon ? { icon } : {},
+    window: {
+      width: config.window?.width ?? 1024,
+      height: config.window?.height ?? 768,
+      title: config.window?.title?.trim() || name
+    },
+    shell,
+    shellPackage: resolveFarmDesktopShellPackage(shell)
+  };
+}
+function getFarmDesktopOutputDirs(distDir) {
+  const root = path.join(distDir, "output", "desktop");
+  return {
+    root,
+    server: path.join(root, "server"),
+    shell: path.join(root, "shell"),
+    dist: path.join(root, "dist"),
+    devData: path.join(distDir, "data", "desktop")
+  };
+}
+function getFarmHostDesktopOS(platform = process.platform) {
+  return platform === "darwin" ? "macos" : platform === "win32" ? "windows" : "linux";
+}
+var DESKTOP_OS = /* @__PURE__ */ new Set(["macos", "windows", "linux"]);
+function createFarmDesktopContext(options) {
+  const os = options.os ?? getFarmHostDesktopOS();
+  if (!DESKTOP_OS.has(os)) {
+    throw new TypeError(`--os must be macos, windows, or linux, got "${os}".`);
+  }
+  const profile = options.profile ?? "production";
+  if (typeof profile !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(profile)) {
+    throw new TypeError(`--profile must be a name such as "beta", got "${String(profile)}".`);
+  }
+  return Object.freeze({
+    os,
+    mode: options.mode,
+    command: options.command,
+    profile,
+    env: Object.freeze({ ...process.env }),
+    root: options.root
+  });
+}
+async function resolveFarmDesktopBlock(input, context, cache) {
+  if (typeof input !== "function") {
+    return validateFarmDesktopConfig(input, context) ?? {};
+  }
+  const call = () => Promise.resolve().then(() => input(context)).then((value) => validateFarmDesktopConfig(value, context) ?? {});
+  if (!cache) return call();
+  const key = [
+    context.os,
+    context.mode,
+    context.command,
+    context.profile,
+    context.root,
+    String(input)
+  ].join("\0");
+  let resolved = cache.get(key);
+  if (!resolved) {
+    resolved = call();
+    cache.set(key, resolved);
+    resolved.catch(() => cache.delete(key));
+  }
+  return resolved;
+}
+var FARM_DESKTOP_SETUP = /* @__PURE__ */ Symbol.for("@farm.js/core/desktop-setup");
+async function createFarmDesktopSetup(userConfig, root, mode, options, cache) {
+  if (resolveFarmPlatform() !== "desktop") return void 0;
+  if (userConfig.desktop === void 0) {
+    throw new Error(
+      '--desktop needs a `desktop` entry in farm.config.ts, for example `desktop: { name: "Notes" }`.'
+    );
+  }
+  const context = createFarmDesktopContext({ ...options, root, mode });
+  const block = await resolveFarmDesktopBlock(userConfig.desktop, context, cache);
+  const desktop = resolveFarmDesktopConfig(block, root, context);
+  return {
+    desktop,
+    userConfig: {
+      ...userConfig,
+      // Only the resolved block goes on; the function stays in the CLI.
+      desktop: block,
+      agent: {
+        jsonLd: false,
+        llmsTxt: false,
+        sitemap: false,
+        aiCatalog: false,
+        manifest: false,
+        mcp: false,
+        ...userConfig.agent
+      },
+      images: userConfig.images?.provider === void 0 ? { ...userConfig.images, provider: "none" } : userConfig.images
+    },
+    // On Bun by default; the CLI picks node-server for shells that embed Node. A platform
+    // build environment (VERCEL=1) must not move it either.
+    deploy: {
+      preset: "bun",
+      outputDir: getFarmDesktopOutputDirs(userConfig.distDir || ".farm").server,
+      env: {}
+    }
+  };
+}
+function installFarmDesktopSetup(options) {
+  const cache = /* @__PURE__ */ new Map();
+  globalThis[FARM_DESKTOP_SETUP] = (userConfig, root, mode) => createFarmDesktopSetup(userConfig, root, mode, options, cache);
+}
+
+export {
+  FARM_DESKTOP_DEV_SESSION,
+  setFarmDesktopDevSession,
+  resolveFarmPlatform,
+  validateFarmDesktopConfig,
+  resolveFarmDesktopConfig,
+  getFarmDesktopOutputDirs,
+  createFarmDesktopContext,
+  resolveFarmDesktopBlock,
+  installFarmDesktopSetup
+};

package/dist/chunk-LM2YOGDK.mjs

@@ -0,0 +1,44 @@
+import {
+  DEFAULT_FARM_API_BASE_PATH,
+  normalizeFarmAPIBasePath,
+  resolveFarmAPIRequestURL
+} from "./chunk-BLD5GVCG.mjs";
+
+// src/api/server-path.ts
+function resolveFarmAPIServerBasePath(config) {
+  return config.baseURL.startsWith("/") ? config.basePath : DEFAULT_FARM_API_BASE_PATH;
+}
+function resolveFarmAPICanonicalPathname(pathname, serverBasePath = DEFAULT_FARM_API_BASE_PATH) {
+  const basePath = normalizeFarmAPIBasePath(serverBasePath);
+  if (basePath === DEFAULT_FARM_API_BASE_PATH) return pathname;
+  if (basePath === "/") {
+    return pathname === "/" ? DEFAULT_FARM_API_BASE_PATH : `${DEFAULT_FARM_API_BASE_PATH}${pathname.startsWith("/") ? pathname : `/${pathname}`}`;
+  }
+  if (pathname === basePath) return DEFAULT_FARM_API_BASE_PATH;
+  if (pathname.startsWith(`${basePath}/`)) {
+    return `${DEFAULT_FARM_API_BASE_PATH}${pathname.slice(basePath.length)}`;
+  }
+  return pathname;
+}
+function createFarmAPIMiddlewarePathnames(serverBasePath = DEFAULT_FARM_API_BASE_PATH) {
+  const basePath = normalizeFarmAPIBasePath(serverBasePath);
+  if (basePath === DEFAULT_FARM_API_BASE_PATH) return (pathname) => [pathname];
+  const prefix = DEFAULT_FARM_API_BASE_PATH;
+  return (pathname) => {
+    const canonical = resolveFarmAPICanonicalPathname(pathname, basePath);
+    if (canonical !== prefix && !canonical.startsWith(`${prefix}/`)) return [pathname];
+    const suffix = canonical.slice(prefix.length);
+    const publicPath = basePath === "/" ? suffix || "/" : `${basePath}${suffix}`;
+    return [.../* @__PURE__ */ new Set([pathname, canonical, publicPath])];
+  };
+}
+function resolveFarmAPIServerRoutePath(routePath, serverBasePath = DEFAULT_FARM_API_BASE_PATH) {
+  return resolveFarmAPIRequestURL(routePath, serverBasePath).pathname;
+}
+
+export {
+  resolveFarmAPIServerBasePath,
+  resolveFarmAPICanonicalPathname,
+  createFarmAPIMiddlewarePathnames,
+  resolveFarmAPIServerRoutePath
+};