@farm.js/core 0.1.48 → 0.1.50

package/dist/{chunk-HNAUK3SC.mjs → chunk-SHJJM6OG.mjs}

@@ -1,12 +1,16 @@
+import {
+  createRouteTypeDeclarations,
+  generateRouteTypes
+} from "./chunk-2G63BIRL.mjs";
 import {
   readSchemaTables
 } from "./chunk-2DLGV2ZG.mjs";
-import {
-  APITypeGenerator
-} from "./chunk-HPP2II4Z.mjs";
 import {
   resolveSchemaModels
 } from "./chunk-F3N52U7S.mjs";
+import {
+  APITypeGenerator
+} from "./chunk-HPP2II4Z.mjs";
 import {
   getOptionalCatchAllParameterNames,
   materializeSSGRoutePath,
@@ -20,28 +24,16 @@ import {
 import {
   writeFileIfChanged
 } from "./chunk-Q5B4LNON.mjs";
-import {
-  resolveFarmComponentExtensions
-} from "./chunk-ES2LD2YD.mjs";
 import {
   getFarmAppDirectories,
   getFarmSourceRoots
 } from "./chunk-52Y3C3HG.mjs";
-import {
-  parseRouteSlotFile
-} from "./chunk-CBJKDB6F.mjs";
-import {
-  discoverProgrammaticRoutePaths
-} from "./chunk-2H3FJYY6.mjs";
 import {
   readFarmI18nCatalogs
 } from "./chunk-DU4VHHPJ.mjs";
 import {
   resolvePluginRoutes
 } from "./chunk-R62SF5R4.mjs";
-import {
-  parseRoutePath
-} from "./chunk-2SVJGOAX.mjs";
 
 // src/ssg.ts
 import { readFileSync } from "fs";
@@ -511,163 +503,13 @@ function matchSSGPage(urlPath, ssgPages) {
   return ssgPages.find((page) => page.urlPath === normalizedPath);
 }
 
-// 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 { root, srcDir = "src", extraRoutes = [], suppressLintOnLink = false } = options;
-  const sourceRoots = options.sourceRoots ?? [{ name: "project", root, srcDir, layer: false }];
-  const componentExtensions = resolveFarmComponentExtensions(options.componentExtensions).map(
-    (extension) => extension.slice(1)
-  );
-  const patterns = /* @__PURE__ */ new Set();
-  const routeModulePatterns = /* @__PURE__ */ new Set();
-  const glob = await import("fast-glob");
-  for (const source of sourceRoots) {
-    const appDir = path.join(source.root, source.srcDir, "app");
-    if (fs.existsSync(appDir)) {
-      const routeModuleFiles = await glob.default(
-        `**/{page,layout,loading,error}.{${componentExtensions.join(",")},md,mdx}`,
-        {
-          cwd: appDir,
-          absolute: false
-        }
-      );
-      for (const file of routeModuleFiles) {
-        if (parseRouteSlotFile(file)) continue;
-        const route = parseRoutePath(file);
-        const pattern = createRoutePattern(route);
-        routeModulePatterns.add(pattern);
-        if (route.type === "page") {
-          patterns.add(pattern);
-        }
-      }
-    }
-    for (const route of await discoverProgrammaticRoutePaths(source.root, source.srcDir)) {
-      patterns.add(route);
-      routeModulePatterns.add(route);
-    }
-  }
-  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;
-}
-
 // src/image-types.ts
-import { mkdirSync as mkdirSync2 } from "fs";
-import path2 from "path";
+import { mkdirSync } from "fs";
+import path from "path";
 var FARM_STATIC_IMAGE_EXTENSIONS = ["avif", "gif", "jpeg", "jpg", "png", "webp"];
 function generateFarmImageTypes(options) {
-  const outputPath = options.outFile ? path2.resolve(options.root, options.outFile) : path2.join(options.root, options.srcDir || "src", "farm-images.d.ts");
-  mkdirSync2(path2.dirname(outputPath), { recursive: true });
+  const outputPath = options.outFile ? path.resolve(options.root, options.outFile) : path.join(options.root, options.srcDir || "src", "farm-images.d.ts");
+  mkdirSync(path.dirname(outputPath), { recursive: true });
   writeFileIfChanged(outputPath, createFarmImageTypeDeclarations());
   return outputPath;
 }
@@ -693,14 +535,14 @@ declare module "*?url" {
 }
 
 // src/i18n/type-generator.ts
-import { mkdirSync as mkdirSync3 } from "fs";
-import { dirname as dirname2, join as join2, resolve as resolve2 } from "path";
+import { mkdirSync as mkdirSync2 } from "fs";
+import { dirname, join, resolve } from "path";
 async function generateFarmI18nTypes(options) {
   if (!options.config.enabled) return void 0;
   const { signatures } = await readFarmI18nCatalogs(options.config);
-  const outFile = options.outFile ? resolve2(options.root, options.outFile) : join2(resolve2(options.root), options.srcDir || "src", "farm-i18n.d.ts");
+  const outFile = options.outFile ? resolve(options.root, options.outFile) : join(resolve(options.root), options.srcDir || "src", "farm-i18n.d.ts");
   const content = renderFarmI18nTypes(options.config.locales, signatures);
-  mkdirSync3(dirname2(outFile), { recursive: true });
+  mkdirSync2(dirname(outFile), { recursive: true });
   writeFileIfChanged(outFile, content);
   return outFile;
 }
@@ -743,12 +585,12 @@ function argumentType(kind) {
 }
 
 // src/type-artifacts.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync4, readFileSync as readFileSync2, unlinkSync } from "fs";
-import { dirname as dirname4, isAbsolute as isAbsolute3, join as join4, resolve as resolve4 } from "path";
+import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync2, unlinkSync } from "fs";
+import { dirname as dirname3, isAbsolute as isAbsolute2, join as join3, resolve as resolve3 } from "path";
 
 // src/content-types.ts
-import * as fs2 from "fs";
-import * as path3 from "path";
+import * as fs from "fs";
+import * as path2 from "path";
 var CONFIG_FILENAMES = [
   "farm.config.ts",
   "farm.config.tsx",
@@ -768,10 +610,10 @@ var CONFIG_FILENAMES = [
   "config.cjs"
 ];
 function createContentTypeDeclarations(options, outPath) {
-  const root = path3.resolve(options.root);
+  const root = path2.resolve(options.root);
   const projectConfig = findConfigPath(root, options.configPath);
   const configPaths = [
-    ...(options.layerConfigPaths ?? []).filter((value) => fs2.existsSync(value)),
+    ...(options.layerConfigPaths ?? []).filter((value) => fs.existsSync(value)),
     ...projectConfig ? [projectConfig] : []
   ];
   if (configPaths.length === 0) return createEmptyContentTypes();
@@ -839,17 +681,17 @@ export {};
 }
 function findConfigPath(root, configPath) {
   if (configPath) {
-    const resolvedPath = path3.isAbsolute(configPath) ? configPath : path3.join(root, configPath);
-    return fs2.existsSync(resolvedPath) ? resolvedPath : null;
+    const resolvedPath = path2.isAbsolute(configPath) ? configPath : path2.join(root, configPath);
+    return fs.existsSync(resolvedPath) ? resolvedPath : null;
   }
   for (const filename of CONFIG_FILENAMES) {
-    const resolvedPath = path3.join(root, filename);
-    if (fs2.existsSync(resolvedPath)) return resolvedPath;
+    const resolvedPath = path2.join(root, filename);
+    if (fs.existsSync(resolvedPath)) return resolvedPath;
   }
   return null;
 }
 function toTypeImportPath(outPath, targetPath) {
-  const relativePath = path3.relative(path3.dirname(outPath), targetPath).replace(/\\/g, "/").replace(/\.(tsx?|jsx?|mjs|cjs|mts|cts)$/, "");
+  const relativePath = path2.relative(path2.dirname(outPath), targetPath).replace(/\\/g, "/").replace(/\.(tsx?|jsx?|mjs|cjs|mts|cts)$/, "");
   return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
 }
 
@@ -925,7 +767,7 @@ function propertyName(key) {
 
 // src/type-artifacts.ts
 async function generateFarmTypeArtifacts(options) {
-  const root = resolve4(options.root);
+  const root = resolve3(options.root);
   const srcDir = options.srcDir || "src";
   const shouldGenerateRoutes = options.routes !== false;
   const shouldGenerateApi = options.api !== false;
@@ -938,7 +780,7 @@ async function generateFarmTypeArtifacts(options) {
     apiRoutes: [],
     stalePaths: []
   };
-  const unifiedTypesPath = join4(root, srcDir, "farm.d.ts");
+  const unifiedTypesPath = join3(root, srcDir, "farm.d.ts");
   const shouldRefreshUnifiedTypes = shouldGenerateRoutes && !options.routeTypesOutFile || shouldGenerateEnv && !options.envTypesOutFile || shouldGenerateI18n && !options.i18nTypesOutFile;
   const unifiedSections = [];
   if (shouldRefreshUnifiedTypes && !options.routeTypesOutFile) {
@@ -974,11 +816,11 @@ async function generateFarmTypeArtifacts(options) {
   if (shouldGenerateApi) {
     const generator = new APITypeGenerator(appDirs);
     const apiRoutes = generator.scanAPIRoutes();
-    const apiTypesPath = options.apiTypesOutFile ? resolve4(root, options.apiTypesOutFile) : join4(root, srcDir, "lib", "api.generated.ts");
+    const apiTypesPath = options.apiTypesOutFile ? resolve3(root, options.apiTypesOutFile) : join3(root, srcDir, "lib", "api.generated.ts");
     const pluginRoutes = resolvePluginRoutes(options.plugins);
     const configFiles = [
       ...(options.layers ?? []).map((layer) => layer.configFile).filter((file) => Boolean(file)),
-      options.configPath ? resolve4(root, options.configPath) : [
+      options.configPath ? resolve3(root, options.configPath) : [
         "farm.config.ts",
         "farm.config.mts",
         "farm.config.js",
@@ -987,14 +829,14 @@ async function generateFarmTypeArtifacts(options) {
         "farm.config.cjs",
         "config.ts",
         "config.js"
-      ].map((name) => join4(root, name)).find((file) => existsSync3(file))
+      ].map((name) => join3(root, name)).find((file) => existsSync2(file))
     ].filter((file) => Boolean(file));
     if (pluginRoutes.length && !configFiles.length) {
       throw new Error(
         "Cannot generate plugin API types without a Farm config file. Pass configPath."
       );
     }
-    if (apiRoutes.length > 0 || pluginRoutes.length > 0 || existsSync3(apiTypesPath)) {
+    if (apiRoutes.length > 0 || pluginRoutes.length > 0 || existsSync2(apiTypesPath)) {
       const content = generator.generateAPIRouter(apiRoutes, {
         outFile: apiTypesPath,
         pluginConfigs: pluginRoutes.length ? [...new Set(configFiles)] : [],
@@ -1119,19 +961,19 @@ function normalizeUnifiedTypeSection(section) {
   return section.trimEnd().replace(/\n+export \{\};$/, "");
 }
 function resolveGeneratedPath(root, srcDir, outFile, relativeToSrc = true) {
-  if (isAbsolute3(outFile)) return resolve4(outFile);
-  return resolve4(root, relativeToSrc ? join4(srcDir, outFile) : outFile);
+  if (isAbsolute2(outFile)) return resolve3(outFile);
+  return resolve3(root, relativeToSrc ? join3(srcDir, outFile) : outFile);
 }
 function writeOrCheckGeneratedFile(filePath, content, check, stalePaths) {
   if (check) {
     checkGeneratedFile(filePath, content, stalePaths);
     return;
   }
-  mkdirSync4(dirname4(filePath), { recursive: true });
+  mkdirSync3(dirname3(filePath), { recursive: true });
   writeFileIfChanged(filePath, content);
 }
 function checkGeneratedFile(filePath, content, stalePaths) {
-  if (!existsSync3(filePath) || readFileSync2(filePath, "utf8") !== content) {
+  if (!existsSync2(filePath) || readFileSync2(filePath, "utf8") !== content) {
     stalePaths.push(filePath);
   }
 }
@@ -1143,8 +985,8 @@ var LEGACY_TYPE_ARTIFACTS = [
 ];
 function removeLegacyTypeArtifacts(root, srcDir) {
   for (const [fileName, marker] of LEGACY_TYPE_ARTIFACTS) {
-    const filePath = join4(root, srcDir, fileName);
-    if (!existsSync3(filePath)) continue;
+    const filePath = join3(root, srcDir, fileName);
+    if (!existsSync2(filePath)) continue;
     const source = readFileSync2(filePath, "utf8");
     if (source.includes(marker)) {
       unlinkSync(filePath);
@@ -1153,8 +995,8 @@ function removeLegacyTypeArtifacts(root, srcDir) {
 }
 function collectLegacyTypeArtifacts(root, srcDir, stalePaths) {
   for (const [fileName, marker] of LEGACY_TYPE_ARTIFACTS) {
-    const filePath = join4(root, srcDir, fileName);
-    if (!existsSync3(filePath)) continue;
+    const filePath = join3(root, srcDir, fileName);
+    if (!existsSync2(filePath)) continue;
     if (readFileSync2(filePath, "utf8").includes(marker)) stalePaths.push(filePath);
   }
 }
@@ -1173,7 +1015,6 @@ export {
   hasPPR,
   generateSSGManifest,
   matchSSGPage,
-  generateRouteTypes,
   generateFarmImageTypes,
   createFarmImageTypeDeclarations,
   generateFarmI18nTypes,

package/dist/{chunk-LL7TDMOM.mjs → chunk-SMUW7UST.mjs}

@@ -1,5 +1,14 @@
+import {
+  createPlatformBlockChecker,
+  isPlainObject,
+  readAppPackageJson,
+  resolveAppPackageName,
+  resolvePlatformBlock,
+  resolvePlatformProfile
+} from "./chunk-UB7RVEMX.mjs";
+
 // src/desktop/config.ts
-import { existsSync, readFileSync } from "fs";
+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");
@@ -9,33 +18,18 @@ function setFarmDesktopDevSession(session) {
   else delete store[FARM_DESKTOP_DEV_SESSION];
 }
 function resolveFarmPlatform(env = process.env) {
-  return env[FARM_PLATFORM_ENV] === "desktop" ? "desktop" : "web";
+  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._-]*)*$/;
-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 desktopChecker(context) {
+  return createPlatformBlockChecker(context ? `desktop (os: ${context.os})` : "desktop");
 }
-function optionalSize(value, key) {
+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.`);
@@ -43,7 +37,11 @@ function optionalSize(value, key) {
   return value;
 }
 function validateFarmDesktopConfig(input, context) {
-  failPrefix = context ? `desktop (os: ${context.os})` : "desktop";
+  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(
@@ -64,8 +62,8 @@ function validateFarmDesktopConfig(input, context) {
   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");
+    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");
@@ -77,14 +75,6 @@ function validateFarmDesktopConfig(input, context) {
   }
   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";
 }
@@ -93,12 +83,13 @@ function resolveFarmDesktopShellPackage(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 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)) fail(`icon ${config.icon} was not found in ${root}.`);
+  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)}`,
@@ -132,10 +123,7 @@ function createFarmDesktopContext(options) {
   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)}".`);
-  }
+  const profile = resolvePlatformProfile(options.profile);
   return Object.freeze({
     os,
     mode: options.mode,
@@ -146,26 +134,12 @@ function createFarmDesktopContext(options) {
   });
 }
 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;
+  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) {

package/dist/{chunk-VCFBQFOV.mjs → chunk-SN5VSO3Q.mjs}

@@ -3,8 +3,9 @@ import {
   isFarmLocaleChangeHref
 } from "./chunk-PTLXHRJZ.mjs";
 import {
-  getHashTargetElement
-} from "./chunk-45EUIICW.mjs";
+  getHashTargetElement,
+  runFarmNavigationDelegates
+} from "./chunk-G2KTRMWA.mjs";
 import {
   isFarmBlockedNavigationURL,
   isFarmExternalNavigationURL,
@@ -252,11 +253,12 @@ var SPARouter = class {
       return;
     }
     const from = window.location.pathname + window.location.search;
-    if (await this.shouldBlockNavigation({
-      from,
-      to: fullPath,
-      action: replace ? "replace" : "push"
-    })) {
+    const action = replace ? "replace" : "push";
+    if (await this.shouldBlockNavigation({ from, to: fullPath, action })) {
+      return;
+    }
+    if (!(refresh && fullPath === from) && await runFarmNavigationDelegates({ url: url.href, from, to: fullPath, action })) {
+      this.cancelActiveNavigation();
       return;
     }
     if (this.options.scrollRestoration) {

package/dist/{chunk-DM3TFCC2.cjs → chunk-SUV6YO4Q.cjs}

@@ -17,18 +17,18 @@ var _chunk5DX3O6TTcjs = require('./chunk-5DX3O6TT.cjs');
 var _chunkEVIWKPJVcjs = require('./chunk-EVIWKPJV.cjs');
 
 
-var _chunk5566GNEGcjs = require('./chunk-5566GNEG.cjs');
+var _chunkLIFUPCXWcjs = require('./chunk-LIFUPCXW.cjs');
 
 
 var _chunkB5BBTPJQcjs = require('./chunk-B5BBTPJQ.cjs');
 
 
-var _chunkA25FXJ7Dcjs = require('./chunk-A25FXJ7D.cjs');
 
 
+var _chunk7JUIK547cjs = require('./chunk-7JUIK547.cjs');
 
 
-var _chunk7JUIK547cjs = require('./chunk-7JUIK547.cjs');
+var _chunkA25FXJ7Dcjs = require('./chunk-A25FXJ7D.cjs');
 
 
 var _chunkOWQV6MLMcjs = require('./chunk-OWQV6MLM.cjs');
@@ -240,7 +240,7 @@ function createHandledResponse(body, init, headers) {
   return new Response(body, { ...init, headers: responseHeaders });
 }
 function createWebMiddlewareContext(request, parent, trustProxy = false, clientAddress, toRoutePathname) {
-  let currentRequest = _chunk5566GNEGcjs.withFarmRequestClientAddress.call(void 0, request, trustProxy, clientAddress);
+  let currentRequest = _chunkLIFUPCXWcjs.withFarmRequestClientAddress.call(void 0, request, trustProxy, clientAddress);
   let handledResponse = null;
   const url = new URL(currentRequest.url);
   const data = _optionalChain([parent, 'optionalAccess', _3 => _3.data]) ? new Map(parent.data) : /* @__PURE__ */ new Map();
@@ -295,7 +295,7 @@ function createWebMiddlewareContext(request, parent, trustProxy = false, clientA
     rewrite(rewriteUrl) {
       ctx._rewriteUrl = rewriteUrl;
       const nextUrl = new URL(rewriteUrl, currentRequest.url);
-      currentRequest = _chunk5566GNEGcjs.withFarmRequestClientAddress.call(void 0, 
+      currentRequest = _chunkLIFUPCXWcjs.withFarmRequestClientAddress.call(void 0, 
         new Request(nextUrl, currentRequest),
         trustProxy,
         clientAddress

package/dist/{chunk-JUMPFVMK.mjs → chunk-TUOO6IK3.mjs}

@@ -1,5 +1,13 @@
 // src/dev-module.ts
 var failedModules = /* @__PURE__ */ new WeakMap();
+var startedContainers = /* @__PURE__ */ new WeakSet();
+async function startPluginContainer(server) {
+  if (server.config?.experimental?.bundledDev) return;
+  const container = server.environments.client?.pluginContainer;
+  if (!container || startedContainers.has(container)) return;
+  await container.buildStart?.();
+  startedContainers.add(container);
+}
 var FarmDevEnvironmentError = class extends Error {
 };
 async function loadFarmDevModule(server, id, environmentName = "ssr") {
@@ -11,6 +19,7 @@ async function loadFarmDevModule(server, id, environmentName = "ssr") {
     );
   }
   try {
+    await startPluginContainer(server);
     return await runner.import(id);
   } catch (error) {
     const failures = failedModules.get(environment) ?? /* @__PURE__ */ new Map();