@farm.js/core 0.1.61 → 0.1.63

package/dist/chunk-4GLOOWKE.mjs

@@ -1,1344 +0,0 @@
-import {
-  APITypeGenerator
-} from "./chunk-F3VB7ONA.mjs";
-import {
-  readSchemaTables
-} from "./chunk-HALDNTIV.mjs";
-import {
-  resolveSchemaModels
-} from "./chunk-ZMSZZXOR.mjs";
-import {
-  mergeRouteRenderingDirectiveConfig
-} from "./chunk-DAO7JGTS.mjs";
-import {
-  createEnvTypeDeclarations,
-  generateEnvTypes
-} from "./chunk-45ZSJLDT.mjs";
-import {
-  writeFileIfChanged
-} from "./chunk-4JCQDWPX.mjs";
-import {
-  getFarmAppDirectories,
-  getFarmSourceRoots
-} from "./chunk-BUGNQIHC.mjs";
-import {
-  resolveFarmComponentExtensions
-} from "./chunk-DAATZTKJ.mjs";
-import {
-  parseRouteSlotFile
-} from "./chunk-RHAZ22ZN.mjs";
-import {
-  discoverProgrammaticRoutePaths
-} from "./chunk-UDNPLXW7.mjs";
-import {
-  readFarmI18nCatalogs
-} from "./chunk-QCFBDFRS.mjs";
-import {
-  resolvePluginRoutes
-} from "./chunk-3UEVPCGW.mjs";
-import {
-  parseRoutePath
-} from "./chunk-KI3MESHB.mjs";
-import {
-  __name
-} from "./chunk-LPEX4YW6.mjs";
-
-// src/ssg.ts
-import { readFile } from "fs/promises";
-var OPTIONAL_CATCH_ALL_SEGMENT = /^\[\[\.\.\.([^\]]+)\]\]$/;
-var REQUIRED_CATCH_ALL_SEGMENT = /^\[\.\.\.([^\]]+)\]$/;
-var REQUIRED_DYNAMIC_SEGMENT = /^\[([^\]]+)\]$/;
-var REQUEST_API_LABELS = /* @__PURE__ */ new Map([
-  ["cookies", "request cookies"],
-  ["headers", "request headers"],
-  ["getCurrentRequest", "the current Request"],
-  ["useSearchParams", "URL search parameters"],
-  ["auth", "request authentication"],
-  ["getServerSession", "request authentication"],
-  ["getSession", "request authentication"],
-  ["currentUser", "request authentication"]
-]);
-var ROUTE_PROP_LABELS = /* @__PURE__ */ new Map([
-  ["searchParams", "URL search parameters"],
-  ["middleware", "middleware request data"],
-  ["middlewareData", "middleware request data"],
-  ["context", "request context"]
-]);
-function resolveConfiguredRouteRenderingConfig(mod, source, options) {
-  return mergeRouteRenderingDirectiveConfig(parseRouteRenderingDirective(source), mod, options);
-}
-__name(resolveConfiguredRouteRenderingConfig, "resolveConfiguredRouteRenderingConfig");
-function resolveRouteRenderingConfig(mod, source, options) {
-  const rendering = resolveConfiguredRouteRenderingConfig(mod, source, options);
-  if (!rendering.ssg || !source) {
-    return rendering;
-  }
-  const requestBlockers = findRequestBoundSourceBlockers(source);
-  if (requestBlockers.length === 0) {
-    return rendering;
-  }
-  return {
-    ...rendering,
-    ssg: false,
-    revalidate: void 0
-  };
-}
-__name(resolveRouteRenderingConfig, "resolveRouteRenderingConfig");
-async function resolveRouteRenderingConfigFromFile(mod, filePath, options) {
-  const source = await readFile(filePath, "utf8").catch(() => void 0);
-  return resolveRouteRenderingConfig(mod, source, options);
-}
-__name(resolveRouteRenderingConfigFromFile, "resolveRouteRenderingConfigFromFile");
-function analyzeStaticRouteCandidate(mod, source, options = {}) {
-  const blockers = [];
-  if (!source) {
-    blockers.push("route source is unavailable");
-  }
-  if (options.isDynamic) {
-    blockers.push("the route has dynamic path segments");
-  }
-  if (hasExplicitRenderingConfig(mod, source)) {
-    blockers.push("the route already has explicit rendering config");
-  }
-  if (source) {
-    blockers.push(...findRequestBoundSourceBlockers(source));
-  }
-  return {
-    candidate: blockers.length === 0,
-    blockers
-  };
-}
-__name(analyzeStaticRouteCandidate, "analyzeStaticRouteCandidate");
-function findRequestBoundSourceBlockers(source) {
-  const blockers = /* @__PURE__ */ new Set();
-  const code = stripCommentsAndLiteralContents(source);
-  const sourceWithoutComments = stripComments(source);
-  for (const binding of readRequestApiImportBindings(sourceWithoutComments)) {
-    if (new RegExp(`\\b${escapeRegExp(binding.local)}\\s*(?:\\?\\.\\s*)?\\(`).test(code)) {
-      blockers.add(`the route reads ${binding.label}`);
-    }
-  }
-  for (const namespace of readNamespaceImportBindings(sourceWithoutComments)) {
-    for (const [name, label] of REQUEST_API_LABELS) {
-      if (new RegExp(
-        `\\b${escapeRegExp(namespace)}\\s*(?:\\?\\.\\s*|\\.\\s*)${name}\\s*(?:\\?\\.\\s*)?\\(`
-      ).test(code)) {
-        blockers.add(`the route reads ${label}`);
-      }
-    }
-  }
-  const params = readDefaultRouteParameters(code);
-  if (params) {
-    for (const [name, label] of ROUTE_PROP_LABELS) {
-      if (new RegExp(`\\b${name}\\b`).test(params)) {
-        blockers.add(`the route reads ${label}`);
-      }
-    }
-    const propsName = params.match(/^\s*([A-Za-z_$][\w$]*)\s*(?::|,|$)/)?.[1];
-    if (propsName) {
-      for (const [name, label] of ROUTE_PROP_LABELS) {
-        if (new RegExp(`\\b${escapeRegExp(propsName)}\\s*\\.\\s*${name}\\b`).test(code)) {
-          blockers.add(`the route reads ${label}`);
-        }
-        if (new RegExp(`\\{[^}]*\\b${name}\\b[^}]*\\}\\s*=\\s*${escapeRegExp(propsName)}\\b`).test(
-          code
-        )) {
-          blockers.add(`the route reads ${label}`);
-        }
-      }
-    }
-  }
-  return [...blockers];
-}
-__name(findRequestBoundSourceBlockers, "findRequestBoundSourceBlockers");
-function readRequestApiImportBindings(source) {
-  const bindings = [];
-  for (const clause of readStaticImportClauses(source)) {
-    const namedGroup = clause.match(/\{([\s\S]*?)\}/)?.[1];
-    for (const rawSpecifier of (namedGroup ?? "").split(",")) {
-      const specifier = rawSpecifier.trim().replace(/^type\s+/, "");
-      const imported = specifier.match(/^([A-Za-z_$][\w$]*)(?:\s+as\s+([A-Za-z_$][\w$]*))?$/);
-      if (!imported?.[1]) continue;
-      const label = REQUEST_API_LABELS.get(imported[1]);
-      if (label) bindings.push({ local: imported[2] ?? imported[1], label });
-    }
-    const local = clause.match(/^\s*([A-Za-z_$][\w$]*)\s*(?:,|$)/)?.[1];
-    if (local) {
-      const label = REQUEST_API_LABELS.get(local);
-      if (label) bindings.push({ local, label });
-    }
-  }
-  return bindings;
-}
-__name(readRequestApiImportBindings, "readRequestApiImportBindings");
-function readNamespaceImportBindings(source) {
-  return readStaticImportClauses(source).map((clause) => clause.match(/\*\s*as\s*([A-Za-z_$][\w$]*)/)?.[1]).filter((binding) => Boolean(binding));
-}
-__name(readNamespaceImportBindings, "readNamespaceImportBindings");
-function readStaticImportClauses(source) {
-  return [...source.matchAll(/\bimport\s+(?!\()([\s\S]*?)\s+from\s*["'][^"']+["']/g)].map((match) => match[1]).filter((clause) => Boolean(clause));
-}
-__name(readStaticImportClauses, "readStaticImportClauses");
-function readDefaultRouteParameters(code) {
-  const inlineParams = code.match(/\bexport\s+default\s+(?:async\s+)?function\b[^(]*\(([^)]*)\)/)?.[1] ?? code.match(/\bexport\s+default\s+(?:async\s+)?\(([^)]*)\)\s*=>/)?.[1];
-  if (inlineParams !== void 0) return inlineParams;
-  const binding = code.match(/\bexport\s+default\s+([A-Za-z_$][\w$]*)\s*;?/)?.[1] ?? code.match(/\bexport\s*\{\s*([A-Za-z_$][\w$]*)\s+as\s+default\s*\}/)?.[1];
-  if (!binding) return void 0;
-  const escapedBinding = escapeRegExp(binding);
-  return code.match(new RegExp(`\\bfunction\\s+${escapedBinding}\\s*\\(([^)]*)\\)`))?.[1] ?? code.match(
-    new RegExp(
-      `\\b(?:const|let|var)\\s+${escapedBinding}\\s*=\\s*(?:async\\s+)?\\(([^)]*)\\)\\s*=>`
-    )
-  )?.[1] ?? code.match(
-    new RegExp(`\\b(?:const|let|var)\\s+${escapedBinding}\\s*=\\s*function\\s*\\(([^)]*)\\)`)
-  )?.[1];
-}
-__name(readDefaultRouteParameters, "readDefaultRouteParameters");
-function stripCommentsAndLiteralContents(source) {
-  return sanitizeSource(source, true);
-}
-__name(stripCommentsAndLiteralContents, "stripCommentsAndLiteralContents");
-function stripComments(source) {
-  return sanitizeSource(source, false);
-}
-__name(stripComments, "stripComments");
-function sanitizeSource(source, maskLiterals) {
-  const output = [...source];
-  const mask = /* @__PURE__ */ __name((index) => {
-    if (output[index] !== "\n" && output[index] !== "\r") output[index] = " ";
-  }, "mask");
-  const scanQuoted = /* @__PURE__ */ __name((start, quote) => {
-    let index = start;
-    if (maskLiterals) mask(index);
-    index += 1;
-    while (index < source.length) {
-      if (source[index] === "\\") {
-        if (maskLiterals) mask(index);
-        if (index + 1 < source.length && maskLiterals) mask(index + 1);
-        index += 2;
-        continue;
-      }
-      const character = source[index];
-      if (maskLiterals) mask(index);
-      index += 1;
-      if (character === quote) break;
-    }
-    return index;
-  }, "scanQuoted");
-  const scanCode = /* @__PURE__ */ __name((start, stopAtTemplateBrace) => {
-    let index = start;
-    let braceDepth = 0;
-    while (index < source.length) {
-      const character = source[index];
-      const next = source[index + 1];
-      if (character === "/" && next === "/") {
-        while (index < source.length && source[index] !== "\n" && source[index] !== "\r") {
-          mask(index++);
-        }
-        continue;
-      }
-      if (character === "/" && next === "*") {
-        mask(index++);
-        mask(index++);
-        while (index < source.length) {
-          const closesComment = source[index] === "*" && source[index + 1] === "/";
-          mask(index++);
-          if (closesComment) {
-            mask(index++);
-            break;
-          }
-        }
-        continue;
-      }
-      if (character === "'" || character === '"') {
-        index = scanQuoted(index, character);
-        continue;
-      }
-      if (character === "`") {
-        if (maskLiterals) mask(index);
-        index += 1;
-        while (index < source.length) {
-          if (source[index] === "\\") {
-            if (maskLiterals) mask(index);
-            if (index + 1 < source.length && maskLiterals) mask(index + 1);
-            index += 2;
-          } else if (source[index] === "`") {
-            if (maskLiterals) mask(index);
-            index += 1;
-            break;
-          } else if (source[index] === "$" && source[index + 1] === "{") {
-            if (maskLiterals) {
-              mask(index);
-              mask(index + 1);
-            }
-            index = scanCode(index + 2, true);
-          } else {
-            if (maskLiterals) mask(index);
-            index += 1;
-          }
-        }
-        continue;
-      }
-      if (character === "{") {
-        braceDepth += 1;
-      } else if (character === "}") {
-        if (stopAtTemplateBrace && braceDepth === 0) {
-          if (maskLiterals) mask(index);
-          return index + 1;
-        }
-        braceDepth = Math.max(0, braceDepth - 1);
-      }
-      index += 1;
-    }
-    return index;
-  }, "scanCode");
-  scanCode(0, false);
-  return output.join("");
-}
-__name(sanitizeSource, "sanitizeSource");
-function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-__name(escapeRegExp, "escapeRegExp");
-function hasExplicitRenderingConfig(mod, source) {
-  return typeof mod?.ssg === "boolean" || typeof mod?.ppr === "boolean" || typeof mod?.experimental_ppr === "boolean" || typeof mod?.revalidate !== "undefined" || typeof mod?.dynamic !== "undefined" || typeof parseRouteRenderingDirective(source) !== "undefined";
-}
-__name(hasExplicitRenderingConfig, "hasExplicitRenderingConfig");
-function parseRouteRenderingDirective(source) {
-  if (!source) {
-    return void 0;
-  }
-  for (const directive of readDirectivePrologue(source)) {
-    const config = parseKnownRenderingDirective(directive);
-    if (config) {
-      return config;
-    }
-  }
-  return void 0;
-}
-__name(parseRouteRenderingDirective, "parseRouteRenderingDirective");
-function parseKnownRenderingDirective(directive) {
-  const normalized = directive.trim().toLowerCase();
-  const match = normalized.match(
-    /^use\s+(ssg|static|isr|ssr|dynamic|ppr)(?:\s*[;:]\s*(\d+))?\s*;?$/
-  );
-  if (!match?.[1]) {
-    return void 0;
-  }
-  const mode = match[1];
-  const revalidate = match[2] ? Number(match[2]) : void 0;
-  if (mode === "ssr" || mode === "dynamic") {
-    return {
-      ssg: false,
-      ppr: false,
-      dynamic: "force-dynamic",
-      directive
-    };
-  }
-  if (mode === "ppr") {
-    return {
-      ssg: false,
-      ppr: true,
-      revalidate: typeof revalidate === "number" && revalidate > 0 ? revalidate : void 0,
-      directive
-    };
-  }
-  return {
-    ssg: true,
-    ppr: false,
-    dynamic: "force-static",
-    revalidate: typeof revalidate === "number" && revalidate > 0 ? revalidate : void 0,
-    directive
-  };
-}
-__name(parseKnownRenderingDirective, "parseKnownRenderingDirective");
-function readDirectivePrologue(source) {
-  const directives = [];
-  let index = skipTrivia(source, 0);
-  while (index < source.length) {
-    const parsed = readStringStatement(source, index);
-    if (!parsed) {
-      break;
-    }
-    directives.push(parsed.value);
-    index = skipTrivia(source, parsed.end);
-  }
-  return directives;
-}
-__name(readDirectivePrologue, "readDirectivePrologue");
-function skipTrivia(source, start) {
-  let index = start;
-  while (index < source.length) {
-    const char = source[index];
-    if (char && /\s/.test(char)) {
-      index += 1;
-      continue;
-    }
-    if (source.startsWith("//", index)) {
-      const nextLine = source.indexOf("\n", index + 2);
-      index = nextLine === -1 ? source.length : nextLine + 1;
-      continue;
-    }
-    if (source.startsWith("/*", index)) {
-      const end = source.indexOf("*/", index + 2);
-      index = end === -1 ? source.length : end + 2;
-      continue;
-    }
-    break;
-  }
-  return index;
-}
-__name(skipTrivia, "skipTrivia");
-function readStringStatement(source, start) {
-  const quote = source[start];
-  if (quote !== '"' && quote !== "'") {
-    return void 0;
-  }
-  let value = "";
-  let index = start + 1;
-  while (index < source.length) {
-    const char = source[index];
-    if (char === "\\") {
-      value += source.slice(index, index + 2);
-      index += 2;
-      continue;
-    }
-    if (char === quote) {
-      index += 1;
-      const semicolonIndex = skipHorizontalWhitespace(source, index);
-      const end = source[semicolonIndex] === ";" ? semicolonIndex + 1 : index;
-      return { value, end };
-    }
-    value += char ?? "";
-    index += 1;
-  }
-  return void 0;
-}
-__name(readStringStatement, "readStringStatement");
-function skipHorizontalWhitespace(source, start) {
-  let index = start;
-  while (source[index] === " " || source[index] === "	" || source[index] === "\r") {
-    index += 1;
-  }
-  return index;
-}
-__name(skipHorizontalWhitespace, "skipHorizontalWhitespace");
-async function collectSSGPages(routes, loadModule, options = {}) {
-  const ssgPages = [];
-  const ssrRoutes = [];
-  const staticCandidateRoutes = [];
-  for (const route of routes) {
-    try {
-      const mod = await loadModule(route.filePath);
-      if (!mod) {
-        ssrRoutes.push(route.path);
-        continue;
-      }
-      const source = await readFile(route.filePath, "utf8").catch(() => void 0);
-      const configuredRendering = resolveConfiguredRouteRenderingConfig(mod, source);
-      const rendering = resolveRouteRenderingConfig(mod, source);
-      if (configuredRendering.ssg && !rendering.ssg && source) {
-        const blockers = findRequestBoundSourceBlockers(source);
-        console.warn(
-          `[Farm.js] Static rendering disabled for "${route.path}" because ${blockers.join(
-            " and "
-          )}. Farm will render this route on each request instead.`
-        );
-      }
-      if (rendering.ssg) {
-        if (route.isDynamic) {
-          const getStaticPaths = mod.getStaticPaths || mod.generateStaticParams;
-          if (!getStaticPaths) {
-            throw new Error(
-              `Dynamic SSG route "${route.path}" requires getStaticPaths export. Add: export function getStaticPaths() { return [{ paramName: 'value' }]; }`
-            );
-          }
-          const paths = await getStaticPaths();
-          const optionalCatchAllParams = getOptionalCatchAllParameterNames(route.path);
-          const materializedPages = paths.map((params) => ({
-            urlPath: materializeSSGRoutePath(route.path, params),
-            filePath: route.filePath,
-            params: normalizeStaticPathParams(params, optionalCatchAllParams),
-            revalidate: rendering.revalidate
-          }));
-          ssgPages.push(...materializedPages);
-        } else {
-          ssgPages.push({
-            urlPath: route.path,
-            filePath: route.filePath,
-            params: {},
-            revalidate: rendering.revalidate
-          });
-        }
-      } else {
-        ssrRoutes.push(route.path);
-        if (options.suggestStaticRendering !== false && analyzeStaticRouteCandidate(mod, source, { isDynamic: route.isDynamic }).candidate) {
-          staticCandidateRoutes.push(route.path);
-        }
-      }
-    } catch (error) {
-      console.error(`Error processing route ${route.path}:`, error);
-      ssrRoutes.push(route.path);
-    }
-  }
-  if (staticCandidateRoutes.length > 0) {
-    const visibleRoutes = staticCandidateRoutes.slice(0, 10);
-    const remainingCount = staticCandidateRoutes.length - visibleRoutes.length;
-    const remainingSuffix = remainingCount > 0 ? `
-  \u2026and ${remainingCount} more` : "";
-    console.warn(
-      `[Farm.js] ${staticCandidateRoutes.length} route${staticCandidateRoutes.length === 1 ? " appears" : "s appear"} eligible for static rendering:
-  ${visibleRoutes.join("\n  ")}${remainingSuffix}
-Add \`export const dynamic = "force-static";\` after verifying that imported code does not read cookies, headers, authentication, or other request data.`
-    );
-  }
-  return { ssg: ssgPages, ssr: ssrRoutes };
-}
-__name(collectSSGPages, "collectSSGPages");
-function materializeSSGRoutePath(routePattern, params) {
-  const outputSegments = [];
-  for (const segment of routePattern.split("/")) {
-    if (!segment) {
-      continue;
-    }
-    const optionalCatchAll = segment.match(OPTIONAL_CATCH_ALL_SEGMENT);
-    if (optionalCatchAll) {
-      const parameterName = optionalCatchAll[1];
-      const value = params[parameterName];
-      const values = readCatchAllSegments(value, {
-        optional: true,
-        parameterName,
-        routePattern
-      });
-      outputSegments.push(...values.map(encodePathSegment));
-      continue;
-    }
-    const requiredCatchAll = segment.match(REQUIRED_CATCH_ALL_SEGMENT);
-    if (requiredCatchAll) {
-      const parameterName = requiredCatchAll[1];
-      const value = params[parameterName];
-      const values = readCatchAllSegments(value, {
-        optional: false,
-        parameterName,
-        routePattern
-      });
-      outputSegments.push(...values.map(encodePathSegment));
-      continue;
-    }
-    const requiredDynamic = segment.match(REQUIRED_DYNAMIC_SEGMENT);
-    if (requiredDynamic) {
-      const parameterName = requiredDynamic[1];
-      const value = params[parameterName];
-      if (isStaticPathArray(value)) {
-        throw new Error(
-          `Cannot materialize SSG route "${routePattern}": parameter "${parameterName}" must be a scalar value; arrays are only supported for catch-all segments.`
-        );
-      }
-      if (isMissingPathValue(value)) {
-        throw missingRequiredParameterError(routePattern, parameterName);
-      }
-      outputSegments.push(encodePathSegment(value));
-      continue;
-    }
-    outputSegments.push(segment);
-  }
-  return outputSegments.length > 0 ? `/${outputSegments.join("/")}` : "/";
-}
-__name(materializeSSGRoutePath, "materializeSSGRoutePath");
-function readCatchAllSegments(value, options) {
-  if (isMissingPathValue(value) || isStaticPathArray(value) && value.length === 0) {
-    if (options.optional) {
-      return [];
-    }
-    throw missingRequiredParameterError(options.routePattern, options.parameterName);
-  }
-  const segments = isStaticPathArray(value) ? [...value] : [value];
-  if (segments.some(isMissingPathValue)) {
-    throw new Error(
-      `Cannot materialize SSG route "${options.routePattern}": catch-all parameter "${options.parameterName}" contains an empty path segment.`
-    );
-  }
-  return segments;
-}
-__name(readCatchAllSegments, "readCatchAllSegments");
-function getOptionalCatchAllParameterNames(routePattern) {
-  return new Set(
-    routePattern.split("/").map((segment) => segment.match(OPTIONAL_CATCH_ALL_SEGMENT)?.[1]).filter((name) => Boolean(name))
-  );
-}
-__name(getOptionalCatchAllParameterNames, "getOptionalCatchAllParameterNames");
-function normalizeStaticPathParams(params, optionalCatchAllParams) {
-  const entries = Object.entries(params).map(([key, value]) => {
-    const emptyOptionalCatchAll = optionalCatchAllParams.has(key) && (isMissingPathValue(value) || isStaticPathArray(value) && value.length === 0);
-    return [
-      key,
-      emptyOptionalCatchAll ? "" : isStaticPathArray(value) ? value.map(String).join("/") : String(value)
-    ];
-  });
-  for (const name of optionalCatchAllParams) {
-    if (!Object.prototype.hasOwnProperty.call(params, name)) {
-      entries.push([name, ""]);
-    }
-  }
-  return Object.fromEntries(entries);
-}
-__name(normalizeStaticPathParams, "normalizeStaticPathParams");
-function isMissingPathValue(value) {
-  return value === "" || value === null || typeof value === "undefined";
-}
-__name(isMissingPathValue, "isMissingPathValue");
-function isStaticPathArray(value) {
-  return Array.isArray(value);
-}
-__name(isStaticPathArray, "isStaticPathArray");
-function missingRequiredParameterError(routePattern, parameterName) {
-  return new Error(
-    `Cannot materialize SSG route "${routePattern}": required parameter "${parameterName}" is missing or empty.`
-  );
-}
-__name(missingRequiredParameterError, "missingRequiredParameterError");
-function encodePathSegment(value) {
-  const encoded = encodeURIComponent(String(value)).replace(
-    /[!'()*]/g,
-    (character) => `%${character.charCodeAt(0).toString(16).toUpperCase()}`
-  );
-  if (encoded === "." || encoded === "..") {
-    throw new Error(
-      `Cannot materialize SSG path segment "${encoded}": dot-only segments are unsafe to prerender.`
-    );
-  }
-  return encoded;
-}
-__name(encodePathSegment, "encodePathSegment");
-function isSSGModule(mod) {
-  return resolveRouteRenderingConfig(mod).ssg;
-}
-__name(isSSGModule, "isSSGModule");
-function hasISR(mod) {
-  const rendering = resolveRouteRenderingConfig(mod);
-  return rendering.ssg && typeof rendering.revalidate === "number" && rendering.revalidate > 0;
-}
-__name(hasISR, "hasISR");
-function getRevalidateInterval(mod) {
-  return resolveRouteRenderingConfig(mod).revalidate;
-}
-__name(getRevalidateInterval, "getRevalidateInterval");
-function hasPPR(mod, options) {
-  return resolveRouteRenderingConfig(mod, void 0, options).ppr;
-}
-__name(hasPPR, "hasPPR");
-function generateSSGManifest(pages) {
-  return JSON.stringify(
-    pages.map((page) => ({
-      urlPath: page.urlPath,
-      params: page.params,
-      revalidate: page.revalidate
-    })),
-    null,
-    2
-  );
-}
-__name(generateSSGManifest, "generateSSGManifest");
-function matchSSGPage(urlPath, ssgPages) {
-  const normalizedPath = urlPath === "/" ? "/" : urlPath.replace(/\/$/, "");
-  return ssgPages.find((page) => page.urlPath === normalizedPath);
-}
-__name(matchSSGPage, "matchSSGPage");
-
-// 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("/") + "`";
-}
-__name(routeSegmentsToTsTypeLiteral, "routeSegmentsToTsTypeLiteral");
-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);
-}
-__name(routePatternToTsTypeLiterals, "routePatternToTsTypeLiterals");
-function routePatternToRouteLiteral(pattern) {
-  return JSON.stringify(pattern);
-}
-__name(routePatternToRouteLiteral, "routePatternToRouteLiteral");
-function renderTypeUnion(values) {
-  return values.length <= 1 ? values[0] || "never" : `
-  | ${values.join("\n  | ")}`;
-}
-__name(renderTypeUnion, "renderTypeUnion");
-function renderTypeAlias(name, value) {
-  return `export type ${name} =${value.startsWith("\n") ? "" : " "}${value};`;
-}
-__name(renderTypeAlias, "renderTypeAlias");
-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("/");
-}
-__name(createRoutePattern, "createRoutePattern");
-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;
-}
-__name(generateRouteTypes, "generateRouteTypes");
-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;
-}
-__name(createRouteTypeDeclarations, "createRouteTypeDeclarations");
-
-// src/image-types.ts
-import { mkdirSync as mkdirSync2 } from "fs";
-import path2 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 });
-  writeFileIfChanged(outputPath, createFarmImageTypeDeclarations());
-  return outputPath;
-}
-__name(generateFarmImageTypes, "generateFarmImageTypes");
-function createFarmImageTypeDeclarations() {
-  const modules = FARM_STATIC_IMAGE_EXTENSIONS.map(
-    (extension) => `declare module "*.${extension}" {
-  const image: import("@farm.js/core/image").StaticImageData;
-  export const src: string;
-  export const width: number;
-  export const height: number;
-  export const blurDataURL: string | undefined;
-  export default image;
-}`
-  );
-  return `// Generated by Farm.js. Do not edit.
-${modules.join("\n\n")}
-
-declare module "*?url" {
-  const src: string;
-  export default src;
-}
-`;
-}
-__name(createFarmImageTypeDeclarations, "createFarmImageTypeDeclarations");
-
-// src/i18n/type-generator.ts
-import { mkdirSync as mkdirSync3 } from "fs";
-import { dirname as dirname2, join as join2, resolve as resolve2 } 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 content = renderFarmI18nTypes(options.config.locales, signatures);
-  mkdirSync3(dirname2(outFile), { recursive: true });
-  writeFileIfChanged(outFile, content);
-  return outFile;
-}
-__name(generateFarmI18nTypes, "generateFarmI18nTypes");
-function renderFarmI18nTypes(locales, signatures) {
-  const localeEntries = locales.map((locale) => `    ${JSON.stringify(locale)}: true;`);
-  const messageEntries = Object.entries(signatures).sort(([a], [b]) => a.localeCompare(b)).map(([key, signature]) => `    ${JSON.stringify(key)}: ${renderSignature(signature)};`);
-  return `// Generated by Farm.js. Do not edit.
-import "@farm.js/core/i18n";
-
-declare module "@farm.js/core/i18n" {
-  interface FarmI18nLocaleRegistry {
-${localeEntries.join("\n")}
-  }
-
-  interface FarmI18nMessageRegistry {
-${messageEntries.join("\n")}
-  }
-}
-
-export {};
-`;
-}
-__name(renderFarmI18nTypes, "renderFarmI18nTypes");
-function renderSignature(signature) {
-  const entries = Object.entries(signature).sort(([a], [b]) => a.localeCompare(b));
-  if (entries.length === 0) return "Record<never, never>";
-  return `{ ${entries.map(([name, kind]) => `${JSON.stringify(name)}: ${argumentType(kind)}`).join("; ")} }`;
-}
-__name(renderSignature, "renderSignature");
-function argumentType(kind) {
-  switch (kind) {
-    case "number":
-      return "number";
-    case "date":
-      return "Date | number";
-    case "rich":
-      return "(chunks: unknown[]) => unknown";
-    case "select":
-    case "string":
-      return "string";
-  }
-}
-__name(argumentType, "argumentType");
-
-// src/type-artifacts.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync4, readFileSync, unlinkSync } from "fs";
-import { dirname as dirname4, isAbsolute as isAbsolute3, join as join4, resolve as resolve4 } from "path";
-
-// src/content-types.ts
-import * as fs2 from "fs";
-import * as path3 from "path";
-var CONFIG_FILENAMES = [
-  "farm.config.ts",
-  "farm.config.tsx",
-  "farm.config.mts",
-  "farm.config.cts",
-  "farm.config.js",
-  "farm.config.jsx",
-  "farm.config.mjs",
-  "farm.config.cjs",
-  "config.ts",
-  "config.tsx",
-  "config.mts",
-  "config.cts",
-  "config.js",
-  "config.jsx",
-  "config.mjs",
-  "config.cjs"
-];
-function createContentTypeDeclarations(options, outPath) {
-  const root = path3.resolve(options.root);
-  const projectConfig = findConfigPath(root, options.configPath);
-  const configPaths = [
-    ...(options.layerConfigPaths ?? []).filter((value) => fs2.existsSync(value)),
-    ...projectConfig ? [projectConfig] : []
-  ];
-  if (configPaths.length === 0) return createEmptyContentTypes();
-  const imports = configPaths.map(
-    (configPath, index) => `import type FarmContentConfig${index} from ${JSON.stringify(toTypeImportPath(outPath, configPath))};`
-  ).join("\n");
-  const registries = configPaths.map(
-    (_configPath, index) => `type FarmContentRegistry${index} = ContentRegistryFromConfig<typeof FarmContentConfig${index}>;`
-  ).join("\n");
-  const registryUnion = configPaths.map((_configPath, index) => `FarmContentRegistry${index}`).join(" | ");
-  return `/**
- * Auto-generated content collection types from Farm layers and farm.config.
- * Regenerated on dev start, build, and farm generate.
- */
-${imports}
-
-type FarmContentPluginFromConfig<TConfig> = TConfig extends {
-  plugins?: readonly (infer TPlugin)[];
-}
-  ? Extract<TPlugin, { readonly __farmContentRegistry: Record<string, unknown> }>
-  : never;
-type ContentRegistryFromConfig<TConfig> =
-  FarmContentPluginFromConfig<TConfig> extends {
-    readonly __farmContentRegistry: infer TRegistry;
-  }
-    ? TRegistry
-    : never;
-type FarmContentUnionToIntersection<TValue> = (
-  TValue extends unknown ? (value: TValue) => void : never
-) extends (value: infer TIntersection) => void
-  ? TIntersection
-  : never;
-${registries}
-
-type FarmResolvedContentRegistry = [${registryUnion}] extends [never]
-  ? {}
-  : FarmContentUnionToIntersection<${registryUnion}>;
-
-declare global {
-  namespace FarmJS {
-    interface ContentRegistry {
-      collections: FarmResolvedContentRegistry;
-    }
-  }
-}
-
-export {};
-`;
-}
-__name(createContentTypeDeclarations, "createContentTypeDeclarations");
-function createEmptyContentTypes() {
-  return `/**
- * Auto-generated content collection types from farm.config.
- * Regenerated on dev start, build, and farm generate.
- */
-declare global {
-  namespace FarmJS {
-    interface ContentRegistry {
-      collections: {};
-    }
-  }
-}
-
-export {};
-`;
-}
-__name(createEmptyContentTypes, "createEmptyContentTypes");
-function findConfigPath(root, configPath) {
-  if (configPath) {
-    const resolvedPath = path3.isAbsolute(configPath) ? configPath : path3.join(root, configPath);
-    return fs2.existsSync(resolvedPath) ? resolvedPath : null;
-  }
-  for (const filename of CONFIG_FILENAMES) {
-    const resolvedPath = path3.join(root, filename);
-    if (fs2.existsSync(resolvedPath)) return resolvedPath;
-  }
-  return null;
-}
-__name(findConfigPath, "findConfigPath");
-function toTypeImportPath(outPath, targetPath) {
-  const relativePath = path3.relative(path3.dirname(outPath), targetPath).replace(/\\/g, "/").replace(/\.(tsx?|jsx?|mjs|cjs|mts|cts)$/, "");
-  return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
-}
-__name(toTypeImportPath, "toTypeImportPath");
-
-// src/schema-model-types.ts
-function createSyncModelTypeDeclarations(plugins) {
-  const rowEntries = [];
-  const insertEntries = [];
-  for (const plugin of plugins ?? []) {
-    const declaration = readSchemaTables(plugin);
-    if (!declaration || declaration.name !== "sync") continue;
-    const exposed = declaration.models ? new Set(declaration.models) : null;
-    const models = resolveSchemaModels(declaration.name, declaration.schema);
-    for (const [modelKey, model] of Object.entries(models)) {
-      if (exposed && !exposed.has(modelKey)) continue;
-      if (model.external) continue;
-      rowEntries.push(renderModelEntry(modelKey, model.fields, "row"));
-      insertEntries.push(renderModelEntry(modelKey, model.fields, "insert"));
-    }
-  }
-  if (rowEntries.length === 0) return null;
-  return `/**
- * Sync model types from the schema passed to sync() in farm.config.
- * useLiveQuery, useRow, and useSyncAction resolve model names and row
- * types against these maps. Regenerated when the schema changes.
- */
-declare module "@farm.js/sync/client" {
-  interface SyncModels {
-${rowEntries.join("\n")}
-  }
-
-  interface SyncModelInputs {
-${insertEntries.join("\n")}
-  }
-}`;
-}
-__name(createSyncModelTypeDeclarations, "createSyncModelTypeDeclarations");
-function renderModelEntry(modelKey, fields, shape) {
-  const lines = Object.entries(fields).map(([fieldKey, field]) => {
-    const nullable = field.nullable === true || field.required === false;
-    const optional = shape === "insert" && (nullable || field.primaryKey === true || field.default !== void 0 || isCursorField(fieldKey, field));
-    const type = `${fieldTsType(field)}${nullable ? " | null" : ""}`;
-    return `      ${propertyName(fieldKey)}${optional ? "?" : ""}: ${type};`;
-  });
-  return `    ${propertyName(modelKey)}: {
-${lines.join("\n")}
-    };`;
-}
-__name(renderModelEntry, "renderModelEntry");
-function fieldTsType(field) {
-  const base = (() => {
-    switch (field.type) {
-      case "boolean":
-        return "boolean";
-      case "integer":
-      case "number":
-        return "number";
-      case "json":
-        return "unknown";
-      case "enum":
-        return field.values?.length ? field.values.map((value) => JSON.stringify(value)).join(" | ") : "string";
-      // id, uuid, string, text, datetime all travel as strings over JSON.
-      default:
-        return "string";
-    }
-  })();
-  if (!field.list) return base;
-  return base.includes(" ") ? `(${base})[]` : `${base}[]`;
-}
-__name(fieldTsType, "fieldTsType");
-function isCursorField(fieldKey, field) {
-  return field.type === "datetime" && (fieldKey === "updatedAt" || field.name === "updated_at");
-}
-__name(isCursorField, "isCursorField");
-function propertyName(key) {
-  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
-}
-__name(propertyName, "propertyName");
-
-// src/type-artifacts.ts
-async function generateFarmTypeArtifacts(options) {
-  const root = resolve4(options.root);
-  const srcDir = options.srcDir || "src";
-  const shouldGenerateRoutes = options.routes !== false;
-  const shouldGenerateApi = options.api !== false;
-  const shouldGenerateEnv = options.env !== false;
-  const shouldGenerateImages = options.images !== false;
-  const shouldGenerateI18n = options.i18n !== false && options.i18nConfig?.enabled;
-  const sourceRoots = getFarmSourceRoots({ root, srcDir, layers: options.layers });
-  const appDirs = getFarmAppDirectories({ root, srcDir, layers: options.layers });
-  const result = {
-    apiRoutes: [],
-    stalePaths: []
-  };
-  const unifiedTypesPath = join4(root, srcDir, "farm.d.ts");
-  const shouldRefreshUnifiedTypes = shouldGenerateRoutes && !options.routeTypesOutFile || shouldGenerateEnv && !options.envTypesOutFile || shouldGenerateI18n && !options.i18nTypesOutFile;
-  const unifiedSections = [];
-  if (shouldRefreshUnifiedTypes && !options.routeTypesOutFile) {
-    const routeOptions = {
-      root,
-      srcDir,
-      extraRoutes: options.extraRoutes || [],
-      suppressLintOnLink: options.suppressLintOnLink,
-      componentExtensions: options.componentExtensions,
-      sourceRoots
-    };
-    unifiedSections.push(await createRouteTypeDeclarations(routeOptions, unifiedTypesPath));
-    result.routeTypesPath = unifiedTypesPath;
-  } else if (shouldGenerateRoutes) {
-    const routeOptions = {
-      root,
-      srcDir,
-      outFile: options.routeTypesOutFile,
-      extraRoutes: options.extraRoutes || [],
-      suppressLintOnLink: options.suppressLintOnLink,
-      componentExtensions: options.componentExtensions,
-      sourceRoots
-    };
-    if (options.check) {
-      const routeTypesPath = resolveGeneratedPath(root, srcDir, options.routeTypesOutFile);
-      const content = await createRouteTypeDeclarations(routeOptions, routeTypesPath);
-      checkGeneratedFile(routeTypesPath, content, result.stalePaths);
-      result.routeTypesPath = routeTypesPath;
-    } else {
-      result.routeTypesPath = await generateRouteTypes(routeOptions);
-    }
-  }
-  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 pluginRoutes = resolvePluginRoutes(options.plugins);
-    const configFiles = [
-      ...(options.layers ?? []).map((layer) => layer.configFile).filter((file) => Boolean(file)),
-      options.configPath ? resolve4(root, options.configPath) : [
-        "farm.config.ts",
-        "farm.config.mts",
-        "farm.config.js",
-        "farm.config.mjs",
-        "farm.config.cts",
-        "farm.config.cjs",
-        "config.ts",
-        "config.js"
-      ].map((name) => join4(root, name)).find((file) => existsSync3(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)) {
-      const content = generator.generateAPIRouter(apiRoutes, {
-        outFile: apiTypesPath,
-        pluginConfigs: pluginRoutes.length ? [...new Set(configFiles)] : [],
-        pluginRoutes
-      });
-      writeOrCheckGeneratedFile(apiTypesPath, content, options.check, result.stalePaths);
-      result.apiTypesPath = apiTypesPath;
-    }
-    result.apiRoutes = apiRoutes;
-  }
-  if (shouldRefreshUnifiedTypes && !options.envTypesOutFile) {
-    unifiedSections.push(
-      createEnvTypeDeclarations(
-        {
-          root,
-          srcDir,
-          configPath: options.configPath,
-          layerConfigPaths: (options.layers ?? []).map((layer) => layer.configFile).filter((configFile) => Boolean(configFile))
-        },
-        unifiedTypesPath
-      )
-    );
-    result.envTypesPath = unifiedTypesPath;
-  } else if (shouldGenerateEnv) {
-    const envOptions = {
-      root,
-      srcDir,
-      outFile: options.envTypesOutFile,
-      configPath: options.configPath,
-      layerConfigPaths: (options.layers ?? []).map((layer) => layer.configFile).filter((configFile) => Boolean(configFile))
-    };
-    if (options.check) {
-      const envTypesPath = resolveGeneratedPath(root, srcDir, options.envTypesOutFile);
-      checkGeneratedFile(
-        envTypesPath,
-        createEnvTypeDeclarations(envOptions, envTypesPath),
-        result.stalePaths
-      );
-      result.envTypesPath = envTypesPath;
-    } else {
-      result.envTypesPath = await generateEnvTypes(envOptions);
-    }
-  }
-  if (shouldGenerateImages && options.imageTypesOutFile) {
-    const imageTypesPath = resolveGeneratedPath(root, srcDir, options.imageTypesOutFile, false);
-    if (options.check) {
-      checkGeneratedFile(imageTypesPath, createFarmImageTypeDeclarations(), result.stalePaths);
-      result.imageTypesPath = imageTypesPath;
-    } else {
-      result.imageTypesPath = generateFarmImageTypes({
-        root,
-        srcDir,
-        outFile: options.imageTypesOutFile
-      });
-    }
-  }
-  if (shouldRefreshUnifiedTypes && options.i18nConfig?.enabled && !options.i18nTypesOutFile) {
-    const { signatures } = await readFarmI18nCatalogs(options.i18nConfig);
-    unifiedSections.push(renderFarmI18nTypes(options.i18nConfig.locales, signatures));
-    result.i18nTypesPath = unifiedTypesPath;
-  } else if (shouldGenerateI18n && options.i18nConfig) {
-    if (options.check) {
-      const i18nTypesPath = resolveGeneratedPath(root, srcDir, options.i18nTypesOutFile, false);
-      const { signatures } = await readFarmI18nCatalogs(options.i18nConfig);
-      checkGeneratedFile(
-        i18nTypesPath,
-        renderFarmI18nTypes(options.i18nConfig.locales, signatures),
-        result.stalePaths
-      );
-      result.i18nTypesPath = i18nTypesPath;
-    } else {
-      result.i18nTypesPath = await generateFarmI18nTypes({
-        root,
-        srcDir,
-        config: options.i18nConfig,
-        outFile: options.i18nTypesOutFile
-      });
-    }
-  }
-  if (shouldRefreshUnifiedTypes) {
-    const syncModelTypes = createSyncModelTypeDeclarations(options.plugins);
-    if (syncModelTypes) unifiedSections.push(syncModelTypes);
-  }
-  if (shouldRefreshUnifiedTypes) {
-    unifiedSections.push(
-      createContentTypeDeclarations(
-        {
-          root,
-          configPath: options.configPath,
-          layerConfigPaths: (options.layers ?? []).map((layer) => layer.configFile).filter((configFile) => Boolean(configFile))
-        },
-        unifiedTypesPath
-      )
-    );
-  }
-  if (shouldRefreshUnifiedTypes) {
-    writeOrCheckGeneratedFile(
-      unifiedTypesPath,
-      `/**
- * Generated by Farm.js. Do not edit.
- * Contains project-specific route, environment, content, and internationalization types.
- */
-
-import "@farm.js/core/image";
-import "@farm.js/core/css";
-
-${unifiedSections.map(normalizeUnifiedTypeSection).join("\n\n")}
-`,
-      options.check,
-      result.stalePaths
-    );
-    result.typesPath = unifiedTypesPath;
-    if (options.check) {
-      collectLegacyTypeArtifacts(root, srcDir, result.stalePaths);
-    } else {
-      removeLegacyTypeArtifacts(root, srcDir);
-    }
-  }
-  return result;
-}
-__name(generateFarmTypeArtifacts, "generateFarmTypeArtifacts");
-function normalizeUnifiedTypeSection(section) {
-  return section.trimEnd().replace(/\n+export \{\};$/, "");
-}
-__name(normalizeUnifiedTypeSection, "normalizeUnifiedTypeSection");
-function resolveGeneratedPath(root, srcDir, outFile, relativeToSrc = true) {
-  if (isAbsolute3(outFile)) return resolve4(outFile);
-  return resolve4(root, relativeToSrc ? join4(srcDir, outFile) : outFile);
-}
-__name(resolveGeneratedPath, "resolveGeneratedPath");
-function writeOrCheckGeneratedFile(filePath, content, check, stalePaths) {
-  if (check) {
-    checkGeneratedFile(filePath, content, stalePaths);
-    return;
-  }
-  mkdirSync4(dirname4(filePath), { recursive: true });
-  writeFileIfChanged(filePath, content);
-}
-__name(writeOrCheckGeneratedFile, "writeOrCheckGeneratedFile");
-function checkGeneratedFile(filePath, content, stalePaths) {
-  if (!existsSync3(filePath) || readFileSync(filePath, "utf8") !== content) {
-    stalePaths.push(filePath);
-  }
-}
-__name(checkGeneratedFile, "checkGeneratedFile");
-var LEGACY_TYPE_ARTIFACTS = [
-  ["farm-routes.d.ts", "Auto-generated route types"],
-  ["farm-env.d.ts", "Auto-generated env types"],
-  ["farm-images.d.ts", "Generated by Farm.js"],
-  ["farm-i18n.d.ts", "Generated by Farm.js"]
-];
-function removeLegacyTypeArtifacts(root, srcDir) {
-  for (const [fileName, marker] of LEGACY_TYPE_ARTIFACTS) {
-    const filePath = join4(root, srcDir, fileName);
-    if (!existsSync3(filePath)) continue;
-    const source = readFileSync(filePath, "utf8");
-    if (source.includes(marker)) {
-      unlinkSync(filePath);
-    }
-  }
-}
-__name(removeLegacyTypeArtifacts, "removeLegacyTypeArtifacts");
-function collectLegacyTypeArtifacts(root, srcDir, stalePaths) {
-  for (const [fileName, marker] of LEGACY_TYPE_ARTIFACTS) {
-    const filePath = join4(root, srcDir, fileName);
-    if (!existsSync3(filePath)) continue;
-    if (readFileSync(filePath, "utf8").includes(marker)) stalePaths.push(filePath);
-  }
-}
-__name(collectLegacyTypeArtifacts, "collectLegacyTypeArtifacts");
-
-export {
-  resolveRouteRenderingConfig,
-  resolveRouteRenderingConfigFromFile,
-  analyzeStaticRouteCandidate,
-  findRequestBoundSourceBlockers,
-  parseRouteRenderingDirective,
-  collectSSGPages,
-  isSSGModule,
-  hasISR,
-  getRevalidateInterval,
-  hasPPR,
-  generateSSGManifest,
-  matchSSGPage,
-  generateRouteTypes,
-  generateFarmImageTypes,
-  createFarmImageTypeDeclarations,
-  generateFarmI18nTypes,
-  generateFarmTypeArtifacts
-};