@farm.js/core 0.1.51-beta.3 → 0.1.61

package/dist/chunk-4GLOOWKE.mjs

@@ -0,0 +1,1344 @@
+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
+};