@farm.js/core 0.1.61 → 0.1.63

package/dist/chunk-SA7MLSP4.mjs

@@ -0,0 +1,229 @@
+import {
+  writeFileIfChanged
+} from "./chunk-Q5B4LNON.mjs";
+import {
+  resolveFarmComponentExtensions
+} from "./chunk-ES2LD2YD.mjs";
+import {
+  parseRouteSlotFile
+} from "./chunk-K3RU5MOR.mjs";
+import {
+  discoverProgrammaticRoutePaths
+} from "./chunk-FSXSQQTV.mjs";
+import {
+  parseRoutePath
+} from "./chunk-JSDV2NUN.mjs";
+
+// src/routing/generate-route-types.ts
+import * as path from "path";
+import * as fs from "fs";
+function routeSegmentsToTsTypeLiteral(segments) {
+  if (segments.length === 0) return '"/"';
+  const hasDynamic = segments.some((s) => s.startsWith("["));
+  if (!hasDynamic) return JSON.stringify("/" + segments.join("/"));
+  const parts = segments.map((s) => {
+    if (s.startsWith("[[...") || s.startsWith("[...")) return "${string}";
+    if (s.startsWith("[")) return "${string}";
+    return s;
+  });
+  return "`/" + parts.join("/") + "`";
+}
+function routePatternToTsTypeLiterals(pattern) {
+  if (pattern === "/") return ['"/"'];
+  let variants = [[]];
+  for (const segment of pattern.slice(1).split("/").filter(Boolean)) {
+    if (segment.startsWith("[[...") && segment.endsWith("]]")) {
+      variants = variants.flatMap((parts) => [parts, [...parts, segment]]);
+    } else {
+      variants = variants.map((parts) => [...parts, segment]);
+    }
+  }
+  return variants.map(routeSegmentsToTsTypeLiteral);
+}
+function routePatternToRouteLiteral(pattern) {
+  return JSON.stringify(pattern);
+}
+function renderTypeUnion(values) {
+  return values.length <= 1 ? values[0] || "never" : `
+  | ${values.join("\n  | ")}`;
+}
+function renderTypeAlias(name, value) {
+  return `export type ${name} =${value.startsWith("\n") ? "" : " "}${value};`;
+}
+function createRoutePattern(route) {
+  if (route.segments.length === 0) return "/";
+  return "/" + route.segments.map((seg) => {
+    if (!seg.isDynamic) return seg.segment;
+    if (seg.isCatchAll) return seg.isOptional ? `[[...${seg.segment}]]` : `[...${seg.segment}]`;
+    return `[${seg.segment}]`;
+  }).join("/");
+}
+var DEFAULT_OUT_FILE = "farm-routes.d.ts";
+async function generateRouteTypes(options) {
+  const root = path.resolve(options.root);
+  const srcDir = options.srcDir || "src";
+  const outFile = options.outFile || DEFAULT_OUT_FILE;
+  const outPath = path.isAbsolute(outFile) ? outFile : path.join(root, srcDir, outFile);
+  const content = await createRouteTypeDeclarations(options, outPath);
+  fs.mkdirSync(path.dirname(outPath), { recursive: true });
+  writeFileIfChanged(outPath, content);
+  return outPath;
+}
+async function createRouteTypeDeclarations(options, outPath) {
+  const { extraRoutes = [], suppressLintOnLink = false } = options;
+  const { pages: patterns, modules: routeModulePatterns } = await scanRoutePatterns(options);
+  for (const route of extraRoutes) {
+    if (route.startsWith("/")) {
+      patterns.add(route);
+      routeModulePatterns.add(route);
+    }
+  }
+  const sortedPatterns = Array.from(patterns).sort();
+  const typeLiterals = Array.from(new Set(sortedPatterns.flatMap(routePatternToTsTypeLiterals)));
+  const patternLiterals = sortedPatterns.map(routePatternToRouteLiteral);
+  const routeModulePatternLiterals = Array.from(routeModulePatterns).sort().map(routePatternToRouteLiteral);
+  const routePathType = suppressLintOnLink ? "string" : renderTypeUnion(typeLiterals);
+  const routePatternType = suppressLintOnLink ? "string" : renderTypeUnion(patternLiterals);
+  const routeModulePatternType = renderTypeUnion(routeModulePatternLiterals);
+  const routeTypesImportPath = `./${path.basename(outPath).replace(/\.d\.ts$/, "")}`;
+  const linkAugmentationBlock = suppressLintOnLink ? "" : `
+declare module "@farm.js/core/client" {
+  interface LinkDefaultRoute {
+    _: import(${JSON.stringify(routeTypesImportPath)}).RoutePath;
+    pattern: import(${JSON.stringify(routeTypesImportPath)}).RoutePattern;
+  }
+}
+
+declare module "@farm.js/core" {
+  interface LinkDefaultRoute {
+    _: import(${JSON.stringify(routeTypesImportPath)}).RoutePath;
+    pattern: import(${JSON.stringify(routeTypesImportPath)}).RoutePattern;
+  }
+  // Ensure root import ("@farm.js/core") uses the same typed Link signature as client entry.
+  const Link: typeof import("@farm.js/core/client").Link;
+}
+
+// Internal declaration path used by @farm.js/core root type re-exports.
+declare module "@farm.js/core/dist/client.js" {
+  interface LinkDefaultRoute {
+    _: import(${JSON.stringify(routeTypesImportPath)}).RoutePath;
+    pattern: import(${JSON.stringify(routeTypesImportPath)}).RoutePattern;
+  }
+}
+`;
+  const routeModuleAugmentationBlock = `
+declare global {
+  namespace FarmJS {
+    interface RouteRegistry {
+      pattern: import(${JSON.stringify(routeTypesImportPath)}).RouteModulePattern;
+    }
+  }
+}
+`;
+  const content = `/**
+ * Auto-generated route types from src/app.
+ * Link href and route component props are typed automatically from generated declarations.
+ * Regenerated on dev start and when routes change.
+ * Set suppressLintOnLink: true in farm.config.ts to accept any string on Link href.
+ */
+${renderTypeAlias("RoutePath", routePathType)}
+${renderTypeAlias("RoutePattern", routePatternType)}
+${renderTypeAlias("RouteModulePattern", routeModulePatternType)}${linkAugmentationBlock}${routeModuleAugmentationBlock}
+`;
+  return content;
+}
+var PLATFORM_FILE = /^(?:(page|layout)\.(native|ios|android)\.(?:tsx|ts|jsx|js)|page\.(kt|swift))$/;
+async function scanRoutePatterns(options) {
+  const { root, srcDir = "src" } = options;
+  const sourceRoots = options.sourceRoots ?? [{ name: "project", root, srcDir, layer: false }];
+  const componentExtensions = resolveFarmComponentExtensions(options.componentExtensions).map(
+    (extension) => extension.slice(1)
+  );
+  const pages = /* @__PURE__ */ new Set();
+  const modules = /* @__PURE__ */ new Set();
+  const pageFiles = /* @__PURE__ */ new Map();
+  const nativePages = /* @__PURE__ */ new Map();
+  const nativeLayouts = /* @__PURE__ */ new Map();
+  const { glob } = await import("tinyglobby");
+  for (const source of sourceRoots) {
+    const appDir = path.join(source.root, source.srcDir, "app");
+    if (fs.existsSync(appDir)) {
+      const routeModuleFiles = await glob(
+        `**/{page,layout,loading,error}.{${componentExtensions.join(",")},md,mdx}`,
+        { cwd: appDir, expandDirectories: false }
+      );
+      for (const file of routeModuleFiles) {
+        if (parseRouteSlotFile(file)) continue;
+        const route = parseRoutePath(file);
+        const pattern = createRoutePattern(route);
+        modules.add(pattern);
+        if (route.type === "page") {
+          pages.add(pattern);
+          if (options.platformFiles) pageFiles.set(pattern, path.join(appDir, file));
+        }
+      }
+      if (options.platformFiles) {
+        scanPlatformRouteFiles(
+          appDir,
+          await glob(
+            ["**/{page,layout}.{native,ios,android}.{tsx,ts,jsx,js}", "**/page.{kt,swift}"],
+            { cwd: appDir, expandDirectories: false }
+          ),
+          nativePages,
+          nativeLayouts
+        );
+      }
+    }
+    for (const route of await discoverProgrammaticRoutePaths(source.root, source.srcDir)) {
+      pages.add(route);
+      modules.add(route);
+    }
+  }
+  if (!options.platformFiles) return { pages, modules };
+  const nativeOnlyPages = /* @__PURE__ */ new Set();
+  for (const [pattern, files] of nativePages) {
+    if (pages.has(pattern)) continue;
+    if (files.native) {
+      nativeOnlyPages.add(pattern);
+      continue;
+    }
+    const file = path.relative(root, Object.values(files)[0]);
+    const dir = path.dirname(file);
+    throw new Error(
+      `${file.replace(/\\/g, "/")} has no web page next to it. Add ${path.join(dir, "page.tsx").replace(/\\/g, "/")} (the route's web screen and fallback), or ${path.join(dir, "page.native.tsx").replace(/\\/g, "/")} to make the route native-only on both OSes.`
+    );
+  }
+  return { pages, modules, pageFiles, nativePages, nativeLayouts, nativeOnlyPages };
+}
+function scanPlatformRouteFiles(appDir, files, nativePages, nativeLayouts) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const file of [...files].sort()) {
+    const normalized = file.replace(/\\/g, "/");
+    const match = PLATFORM_FILE.exec(path.posix.basename(normalized));
+    if (!match) continue;
+    const kind = match[1] ?? "page";
+    const platform = match[2] ?? match[3];
+    const twin = path.posix.join(path.posix.dirname(normalized), `${kind}.tsx`);
+    if (kind === "page" && parseRouteSlotFile(twin)) continue;
+    const dir = path.posix.dirname(normalized);
+    const pattern = kind === "page" ? createRoutePattern(parseRoutePath(twin)) : dir === "." ? "/" : `/${dir}`;
+    const key = `${kind}\0${pattern}\0${platform}`;
+    const previous = seen.get(key);
+    if (previous) {
+      throw new Error(
+        `Duplicate ${platform} ${kind} for "${pattern}": found ${previous} and ${normalized} in ${appDir}. Keep one.`
+      );
+    }
+    seen.set(key, normalized);
+    const target = kind === "page" ? nativePages : nativeLayouts;
+    const entry = { ...target.get(pattern) };
+    entry[platform] = path.join(appDir, normalized);
+    target.set(pattern, entry);
+  }
+}
+
+export {
+  generateRouteTypes,
+  createRouteTypeDeclarations,
+  scanRoutePatterns
+};

package/dist/chunk-SBDWCDS6.cjs

@@ -0,0 +1,8 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/api/route-files.ts
+function isFarmAPIRouteFileName(fileName) {
+  return /^route\.(?:ts|tsx|js|jsx)$/.test(fileName);
+}
+
+
+
+exports.isFarmAPIRouteFileName = isFarmAPIRouteFileName;

package/dist/chunk-SF3JB56B.mjs

@@ -0,0 +1,82 @@
+// src/base-path.ts
+var FARM_BASE_PATH = /* @__PURE__ */ Symbol.for("farm.basePath");
+function getFarmGlobalState() {
+  return globalThis;
+}
+function setFarmBasePath(basePath) {
+  getFarmGlobalState()[FARM_BASE_PATH] = normalizeFarmBasePath(basePath);
+}
+function getFarmBasePath() {
+  return getFarmGlobalState()[FARM_BASE_PATH] ?? "";
+}
+function applyFarmBasePath(href, basePath = getFarmBasePath()) {
+  const normalizedBasePath = normalizeFarmBasePath(basePath);
+  if (!normalizedBasePath || !href.startsWith("/") || href.startsWith("//")) return href;
+  const canonicalHref = canonicalizeAppRelativeHref(href);
+  if (canonicalHref === normalizedBasePath || canonicalHref.startsWith(`${normalizedBasePath}/`) || canonicalHref.startsWith(`${normalizedBasePath}?`) || canonicalHref.startsWith(`${normalizedBasePath}#`)) {
+    return canonicalHref;
+  }
+  return `${normalizedBasePath}${canonicalHref}`;
+}
+function canonicalizeAppRelativeHref(href) {
+  const origin = "http://farm.local";
+  const resolved = new URL(href, origin);
+  if (resolved.origin !== origin) {
+    throw new Error("Farm app-relative href cannot change the URL origin.");
+  }
+  return `${resolved.pathname}${resolved.search}${resolved.hash}`;
+}
+function stripFarmBasePath(pathname, basePath = getFarmBasePath()) {
+  const normalizedBasePath = normalizeFarmBasePath(basePath);
+  if (!normalizedBasePath) return pathname || "/";
+  if (pathname === normalizedBasePath) return "/";
+  if (!pathname.startsWith(`${normalizedBasePath}/`)) return pathname || "/";
+  return pathname.slice(normalizedBasePath.length) || "/";
+}
+function normalizeFarmBasePath(basePath) {
+  if (!basePath || basePath === "/") return "";
+  const hasUnstableCharacters = (candidate) => candidate.includes("\\") || Array.from(candidate).some((character) => {
+    const code = character.charCodeAt(0);
+    return code <= 31 || code >= 127 && code <= 159;
+  });
+  if (hasUnstableCharacters(basePath)) {
+    throw new Error("Farm basePath cannot contain backslashes or control characters.");
+  }
+  const pathname = basePath.trim();
+  if (!pathname || pathname === "/") return "";
+  if (pathname.includes("?") || pathname.includes("#")) {
+    throw new Error("Farm basePath cannot contain a query string or hash.");
+  }
+  if (pathname.startsWith("//") || /^[a-z][a-z\d+.-]*:\/\//i.test(pathname)) {
+    throw new Error('Farm basePath must be a pathname such as "/docs", not a URL.');
+  }
+  for (const segment of pathname.split("/")) {
+    let decoded = segment;
+    try {
+      decoded = decodeURIComponent(segment);
+    } catch {
+    }
+    if (hasUnstableCharacters(decoded)) {
+      throw new Error("Farm basePath cannot contain backslashes or control characters.");
+    }
+    if (decoded.includes("/")) {
+      throw new Error("Farm basePath cannot contain percent-encoded path separators.");
+    }
+    if (decoded === "." || decoded === "..") {
+      throw new Error('Farm basePath cannot contain "." or ".." path segments.');
+    }
+  }
+  return `/${pathname}`.replace(/\/{2,}/g, "/").replace(/\/+$/, "");
+}
+function normalizeFarmConfigBasePath(basePath) {
+  return normalizeFarmBasePath(basePath) || "/";
+}
+
+export {
+  setFarmBasePath,
+  getFarmBasePath,
+  applyFarmBasePath,
+  stripFarmBasePath,
+  normalizeFarmBasePath,
+  normalizeFarmConfigBasePath
+};

package/dist/chunk-SHD265HW.cjs

@@ -0,0 +1,19 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/schema-capabilities.ts
+function assertNoSchemaListField(field, fieldPath, target) {
+  if (!field.list) {
+    return;
+  }
+  throw new Error(
+    `Schema field "${fieldPath}" declares list: true, but ${target} does not support list fields. Use type: "json" for an array value or model the values in a related table.`
+  );
+}
+
+// src/schema-reference.ts
+function isDatabaseEnforcedReference(reference) {
+  return reference.enforced === void 0 || reference.enforced === "db";
+}
+
+
+
+
+exports.assertNoSchemaListField = assertNoSchemaListField; exports.isDatabaseEnforcedReference = isDatabaseEnforcedReference;

package/dist/chunk-SHIWRBFI.cjs

@@ -0,0 +1,17 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/secret-compare.ts
+function farmSecretsMatch(provided, expected) {
+  if (typeof provided !== "string" || typeof expected !== "string") return false;
+  if (expected.length === 0) return false;
+  let mismatch = provided.length ^ expected.length;
+  const length = Math.max(provided.length, expected.length);
+  for (let index = 0; index < length; index += 1) {
+    const providedCode = index < provided.length ? provided.charCodeAt(index) : 0;
+    const expectedCode = index < expected.length ? expected.charCodeAt(index) : 0;
+    mismatch |= providedCode ^ expectedCode;
+  }
+  return mismatch === 0;
+}
+
+
+
+exports.farmSecretsMatch = farmSecretsMatch;

package/dist/chunk-SM2SYWAR.cjs

@@ -0,0 +1,49 @@
+"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; }// src/docs/adapter-client.ts
+function getFarmDocsAdapterConfigModule(docs) {
+  if (!_optionalChain([docs, 'optionalAccess', _ => _.enabled]) || !_optionalChain([docs, 'access', _2 => _2.adapter, 'optionalAccess', _3 => _3.react]) || !docs.configPath) return void 0;
+  return docs.configPath.endsWith(".json") ? void 0 : docs.configPath.replace(/\\/g, "/");
+}
+function generateFarmDocsAdapterClientRuntime(reactModule, configModule) {
+  if (!reactModule) {
+    return `
+async function hydrateFarmDocsAdapterRuntime() {
+  return false;
+}
+`;
+  }
+  return `
+async function hydrateFarmDocsAdapterRuntime() {
+  const runtime = window.__FARM_DOCS_ADAPTER__;
+  if (!runtime) return false;
+  // The docs server flags pages whose config holds what its JSON copy cannot (icons,
+  // MDX components, callbacks); the adapter restores those from the module itself.
+  // Fetch it alongside the adapter rather than after it: they don't depend on each other.
+  const [FarmDocsAdapterReact, configModule] = await Promise.all([
+    import(${JSON.stringify(reactModule)}),
+    runtime.configModule ? ${configModule ? `import(${JSON.stringify(configModule)})` : "undefined"} : undefined,
+  ]);
+  if (typeof FarmDocsAdapterReact.hydrateFarmDocs !== "function") {
+    throw new Error("The configured Farm docs adapter does not export hydrateFarmDocs().");
+  }
+  FarmDocsAdapterReact.hydrateFarmDocs({
+    config: runtime.config || {},
+    data: runtime.data,
+    ...(configModule ? { configModule: configModule.default ?? configModule } : {}),
+  });
+  return true;
+}
+`;
+}
+
+// src/docs/config-secrets.ts
+function isSecretDocsConfigKey(key) {
+  const normalized = key.replace(/[-_]/g, "").toLowerCase();
+  if (!normalized || normalized.endsWith("env")) return false;
+  return /apikey|token|secret|password|authorization|credential/.test(normalized);
+}
+
+
+
+
+
+exports.getFarmDocsAdapterConfigModule = getFarmDocsAdapterConfigModule; exports.generateFarmDocsAdapterClientRuntime = generateFarmDocsAdapterClientRuntime; exports.isSecretDocsConfigKey = isSecretDocsConfigKey;

package/dist/chunk-SMUW7UST.mjs

@@ -0,0 +1,196 @@
+import {
+  createPlatformBlockChecker,
+  isPlainObject,
+  readAppPackageJson,
+  resolveAppPackageName,
+  resolvePlatformBlock,
+  resolvePlatformProfile
+} from "./chunk-UB7RVEMX.mjs";
+
+// src/desktop/config.ts
+import { existsSync } 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) {
+  const value = env[FARM_PLATFORM_ENV];
+  return value === "desktop" || value === "mobile" ? value : "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._-]*)*$/;
+function desktopChecker(context) {
+  return createPlatformBlockChecker(context ? `desktop (os: ${context.os})` : "desktop");
+}
+function optionalSize({ fail }, 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) {
+  const check = desktopChecker(context);
+  const { checkKeys, optionalString } = check;
+  function fail(message) {
+    return check.fail(message);
+  }
+  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(check, input.window.width, "window.width");
+    optionalSize(check, 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 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 = readAppPackageJson(root);
+  const packageName = resolveAppPackageName(root, pkg);
+  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))
+    desktopChecker(context).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 = resolvePlatformProfile(options.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) {
+  return resolvePlatformBlock(
+    input,
+    context,
+    (value, ctx) => validateFarmDesktopConfig(value, ctx) ?? {},
+    cache
+  );
+}
+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-SNP33A33.cjs

@@ -0,0 +1,9 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/utils/file-module.ts
+var _url = require('url');
+function toFileModuleUrl(filePath) {
+  return _url.pathToFileURL.call(void 0, filePath).href;
+}
+
+
+
+exports.toFileModuleUrl = toFileModuleUrl;