@farm.js/core 0.1.47 → 0.1.49

package/dist/chunk-ZSIGEHSE.cjs

@@ -0,0 +1,1181 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkSYW346ZNcjs = require('./chunk-SYW346ZN.cjs');
+
+
+var _chunkQISW423Scjs = require('./chunk-QISW423S.cjs');
+
+
+var _chunkGBMWLDCCcjs = require('./chunk-GBMWLDCC.cjs');
+
+
+
+
+
+var _chunkEZTKXD6Pcjs = require('./chunk-EZTKXD6P.cjs');
+
+
+
+var _chunkGSVJ3IIFcjs = require('./chunk-GSVJ3IIF.cjs');
+
+
+var _chunk5YPBFMBNcjs = require('./chunk-5YPBFMBN.cjs');
+
+
+var _chunkRD623KW4cjs = require('./chunk-RD623KW4.cjs');
+
+
+
+var _chunk5Y2P454Ocjs = require('./chunk-5Y2P454O.cjs');
+
+
+var _chunkJ2ZEVDEKcjs = require('./chunk-J2ZEVDEK.cjs');
+
+
+var _chunkJZMZKABScjs = require('./chunk-JZMZKABS.cjs');
+
+
+var _chunkBBPDJGCUcjs = require('./chunk-BBPDJGCU.cjs');
+
+
+var _chunk5C7XMKQ4cjs = require('./chunk-5C7XMKQ4.cjs');
+
+
+var _chunkXN2MB4QZcjs = require('./chunk-XN2MB4QZ.cjs');
+
+// src/ssg.ts
+var _fs = require('fs'); var fs = _interopRequireWildcard(_fs); var fs2 = _interopRequireWildcard(_fs);
+var _promises = require('fs/promises');
+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 _chunkEZTKXD6Pcjs.mergeRouteRenderingDirectiveConfig.call(void 0, parseRouteRenderingDirective(source), mod, options);
+}
+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
+  };
+}
+async function resolveRouteRenderingConfigFromFile(mod, filePath, options) {
+  const source = await _promises.readFile.call(void 0, filePath, "utf8").catch(() => void 0);
+  return resolveRouteRenderingConfig(mod, source, options);
+}
+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
+  };
+}
+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 = _optionalChain([params, 'access', _ => _.match, 'call', _2 => _2(/^\s*([A-Za-z_$][\w$]*)\s*(?::|,|$)/), 'optionalAccess', _3 => _3[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];
+}
+function readRequestApiImportBindings(source) {
+  const bindings = [];
+  for (const clause of readStaticImportClauses(source)) {
+    const namedGroup = _optionalChain([clause, 'access', _4 => _4.match, 'call', _5 => _5(/\{([\s\S]*?)\}/), 'optionalAccess', _6 => _6[1]]);
+    for (const rawSpecifier of (_nullishCoalesce(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 (!_optionalChain([imported, 'optionalAccess', _7 => _7[1]])) continue;
+      const label = REQUEST_API_LABELS.get(imported[1]);
+      if (label) bindings.push({ local: _nullishCoalesce(imported[2], () => ( imported[1])), label });
+    }
+    const local = _optionalChain([clause, 'access', _8 => _8.match, 'call', _9 => _9(/^\s*([A-Za-z_$][\w$]*)\s*(?:,|$)/), 'optionalAccess', _10 => _10[1]]);
+    if (local) {
+      const label = REQUEST_API_LABELS.get(local);
+      if (label) bindings.push({ local, label });
+    }
+  }
+  return bindings;
+}
+function readNamespaceImportBindings(source) {
+  return readStaticImportClauses(source).map((clause) => _optionalChain([clause, 'access', _11 => _11.match, 'call', _12 => _12(/\*\s*as\s*([A-Za-z_$][\w$]*)/), 'optionalAccess', _13 => _13[1]])).filter((binding) => Boolean(binding));
+}
+function readStaticImportClauses(source) {
+  return [...source.matchAll(/\bimport\s+(?!\()([\s\S]*?)\s+from\s*["'][^"']+["']/g)].map((match) => match[1]).filter((clause) => Boolean(clause));
+}
+function readDefaultRouteParameters(code) {
+  const inlineParams = _nullishCoalesce(_optionalChain([code, 'access', _14 => _14.match, 'call', _15 => _15(/\bexport\s+default\s+(?:async\s+)?function\b[^(]*\(([^)]*)\)/), 'optionalAccess', _16 => _16[1]]), () => ( _optionalChain([code, 'access', _17 => _17.match, 'call', _18 => _18(/\bexport\s+default\s+(?:async\s+)?\(([^)]*)\)\s*=>/), 'optionalAccess', _19 => _19[1]])));
+  if (inlineParams !== void 0) return inlineParams;
+  const binding = _nullishCoalesce(_optionalChain([code, 'access', _20 => _20.match, 'call', _21 => _21(/\bexport\s+default\s+([A-Za-z_$][\w$]*)\s*;?/), 'optionalAccess', _22 => _22[1]]), () => ( _optionalChain([code, 'access', _23 => _23.match, 'call', _24 => _24(/\bexport\s*\{\s*([A-Za-z_$][\w$]*)\s+as\s+default\s*\}/), 'optionalAccess', _25 => _25[1]])));
+  if (!binding) return void 0;
+  const escapedBinding = escapeRegExp(binding);
+  return _nullishCoalesce(_nullishCoalesce(_optionalChain([code, 'access', _26 => _26.match, 'call', _27 => _27(new RegExp(`\\bfunction\\s+${escapedBinding}\\s*\\(([^)]*)\\)`)), 'optionalAccess', _28 => _28[1]]), () => ( _optionalChain([code, 'access', _29 => _29.match, 'call', _30 => _30(
+    new RegExp(
+      `\\b(?:const|let|var)\\s+${escapedBinding}\\s*=\\s*(?:async\\s+)?\\(([^)]*)\\)\\s*=>`
+    )
+  ), 'optionalAccess', _31 => _31[1]]))), () => ( _optionalChain([code, 'access', _32 => _32.match, 'call', _33 => _33(
+    new RegExp(`\\b(?:const|let|var)\\s+${escapedBinding}\\s*=\\s*function\\s*\\(([^)]*)\\)`)
+  ), 'optionalAccess', _34 => _34[1]])));
+}
+function stripCommentsAndLiteralContents(source) {
+  return sanitizeSource(source, true);
+}
+function stripComments(source) {
+  return sanitizeSource(source, false);
+}
+function sanitizeSource(source, maskLiterals) {
+  const output = [...source];
+  const mask = (index) => {
+    if (output[index] !== "\n" && output[index] !== "\r") output[index] = " ";
+  };
+  const scanQuoted = (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;
+  };
+  const scanCode = (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(0, false);
+  return output.join("");
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function hasExplicitRenderingConfig(mod, source) {
+  return typeof _optionalChain([mod, 'optionalAccess', _35 => _35.ssg]) === "boolean" || typeof _optionalChain([mod, 'optionalAccess', _36 => _36.ppr]) === "boolean" || typeof _optionalChain([mod, 'optionalAccess', _37 => _37.experimental_ppr]) === "boolean" || typeof _optionalChain([mod, 'optionalAccess', _38 => _38.revalidate]) !== "undefined" || typeof _optionalChain([mod, 'optionalAccess', _39 => _39.dynamic]) !== "undefined" || typeof parseRouteRenderingDirective(source) !== "undefined";
+}
+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;
+}
+function readRouteRenderingDirectiveFromFile(modulePath) {
+  try {
+    const source = _fs.readFileSync.call(void 0, modulePath, "utf8");
+    const directive = parseRouteRenderingDirective(source);
+    if (findRequestBoundSourceBlockers(source).length === 0) return directive;
+    return { ..._nullishCoalesce(directive, () => ( { ssg: false, ppr: false, directive: "" })), requestBound: true };
+  } catch (e) {
+    return void 0;
+  }
+}
+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 (!_optionalChain([match, 'optionalAccess', _40 => _40[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
+  };
+}
+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;
+}
+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;
+}
+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 += _nullishCoalesce(char, () => ( ""));
+    index += 1;
+  }
+  return void 0;
+}
+function skipHorizontalWhitespace(source, start) {
+  let index = start;
+  while (source[index] === " " || source[index] === "	" || source[index] === "\r") {
+    index += 1;
+  }
+  return index;
+}
+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 _promises.readFile.call(void 0, 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 = _chunkEZTKXD6Pcjs.getOptionalCatchAllParameterNames.call(void 0, route.path);
+          const materializedPages = paths.map((params) => ({
+            urlPath: _chunkEZTKXD6Pcjs.materializeSSGRoutePath.call(void 0, route.path, params),
+            filePath: route.filePath,
+            params: _chunkEZTKXD6Pcjs.normalizeStaticPathParams.call(void 0, 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 };
+}
+function isSSGModule(mod) {
+  return resolveRouteRenderingConfig(mod).ssg;
+}
+function hasISR(mod) {
+  const rendering = resolveRouteRenderingConfig(mod);
+  return rendering.ssg && typeof rendering.revalidate === "number" && rendering.revalidate > 0;
+}
+function getRevalidateInterval(mod) {
+  return resolveRouteRenderingConfig(mod).revalidate;
+}
+function hasPPR(mod, options) {
+  return resolveRouteRenderingConfig(mod, void 0, options).ppr;
+}
+function generateSSGManifest(pages) {
+  return JSON.stringify(
+    pages.map((page) => ({
+      urlPath: page.urlPath,
+      params: page.params,
+      revalidate: page.revalidate
+    })),
+    null,
+    2
+  );
+}
+function matchSSGPage(urlPath, ssgPages) {
+  const normalizedPath = urlPath === "/" ? "/" : urlPath.replace(/\/$/, "");
+  return ssgPages.find((page) => page.urlPath === normalizedPath);
+}
+
+// src/routing/generate-route-types.ts
+var _path = require('path'); var path = _interopRequireWildcard(_path); var path3 = _interopRequireWildcard(_path);
+
+function routeSegmentsToTsTypeLiteral(segments) {
+  if (segments.length === 0) return '"/"';
+  const hasDynamic = segments.some((s) => s.startsWith("["));
+  if (!hasDynamic) return JSON.stringify("/" + segments.join("/"));
+  const parts = segments.map((s) => {
+    if (s.startsWith("[[...") || s.startsWith("[...")) return "${string}";
+    if (s.startsWith("[")) return "${string}";
+    return s;
+  });
+  return "`/" + parts.join("/") + "`";
+}
+function routePatternToTsTypeLiterals(pattern) {
+  if (pattern === "/") return ['"/"'];
+  let variants = [[]];
+  for (const segment of pattern.slice(1).split("/").filter(Boolean)) {
+    if (segment.startsWith("[[...") && segment.endsWith("]]")) {
+      variants = variants.flatMap((parts) => [parts, [...parts, segment]]);
+    } else {
+      variants = variants.map((parts) => [...parts, segment]);
+    }
+  }
+  return variants.map(routeSegmentsToTsTypeLiteral);
+}
+function routePatternToRouteLiteral(pattern) {
+  return JSON.stringify(pattern);
+}
+function renderTypeUnion(values) {
+  return values.length <= 1 ? values[0] || "never" : `
+  | ${values.join("\n  | ")}`;
+}
+function renderTypeAlias(name, value) {
+  return `export type ${name} =${value.startsWith("\n") ? "" : " "}${value};`;
+}
+function createRoutePattern(route) {
+  if (route.segments.length === 0) return "/";
+  return "/" + route.segments.map((seg) => {
+    if (!seg.isDynamic) return seg.segment;
+    if (seg.isCatchAll) return seg.isOptional ? `[[...${seg.segment}]]` : `[...${seg.segment}]`;
+    return `[${seg.segment}]`;
+  }).join("/");
+}
+var DEFAULT_OUT_FILE = "farm-routes.d.ts";
+async function generateRouteTypes(options) {
+  const root = path.resolve(options.root);
+  const srcDir = options.srcDir || "src";
+  const outFile = options.outFile || DEFAULT_OUT_FILE;
+  const outPath = path.isAbsolute(outFile) ? outFile : path.join(root, srcDir, outFile);
+  const content = await createRouteTypeDeclarations(options, outPath);
+  fs.mkdirSync(path.dirname(outPath), { recursive: true });
+  _chunk5YPBFMBNcjs.writeFileIfChanged.call(void 0, outPath, content);
+  return outPath;
+}
+async function createRouteTypeDeclarations(options, outPath) {
+  const { root, srcDir = "src", extraRoutes = [], suppressLintOnLink = false } = options;
+  const sourceRoots = _nullishCoalesce(options.sourceRoots, () => ( [{ name: "project", root, srcDir, layer: false }]));
+  const componentExtensions = _chunkRD623KW4cjs.resolveFarmComponentExtensions.call(void 0, 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 (_chunkJ2ZEVDEKcjs.parseRouteSlotFile.call(void 0, file)) continue;
+        const route = _chunkXN2MB4QZcjs.parseRoutePath.call(void 0, file);
+        const pattern = createRoutePattern(route);
+        routeModulePatterns.add(pattern);
+        if (route.type === "page") {
+          patterns.add(pattern);
+        }
+      }
+    }
+    for (const route of await _chunkJZMZKABScjs.discoverProgrammaticRoutePaths.call(void 0, source.root, source.srcDir)) {
+      patterns.add(route);
+      routeModulePatterns.add(route);
+    }
+  }
+  for (const route of extraRoutes) {
+    if (route.startsWith("/")) {
+      patterns.add(route);
+      routeModulePatterns.add(route);
+    }
+  }
+  const sortedPatterns = Array.from(patterns).sort();
+  const typeLiterals = Array.from(new Set(sortedPatterns.flatMap(routePatternToTsTypeLiterals)));
+  const patternLiterals = sortedPatterns.map(routePatternToRouteLiteral);
+  const routeModulePatternLiterals = Array.from(routeModulePatterns).sort().map(routePatternToRouteLiteral);
+  const routePathType = suppressLintOnLink ? "string" : renderTypeUnion(typeLiterals);
+  const routePatternType = suppressLintOnLink ? "string" : renderTypeUnion(patternLiterals);
+  const routeModulePatternType = renderTypeUnion(routeModulePatternLiterals);
+  const routeTypesImportPath = `./${path.basename(outPath).replace(/\.d\.ts$/, "")}`;
+  const linkAugmentationBlock = suppressLintOnLink ? "" : `
+declare module "@farm.js/core/client" {
+  interface LinkDefaultRoute {
+    _: import(${JSON.stringify(routeTypesImportPath)}).RoutePath;
+    pattern: import(${JSON.stringify(routeTypesImportPath)}).RoutePattern;
+  }
+}
+
+declare module "@farm.js/core" {
+  interface LinkDefaultRoute {
+    _: import(${JSON.stringify(routeTypesImportPath)}).RoutePath;
+    pattern: import(${JSON.stringify(routeTypesImportPath)}).RoutePattern;
+  }
+  // Ensure root import ("@farm.js/core") uses the same typed Link signature as client entry.
+  const Link: typeof import("@farm.js/core/client").Link;
+}
+
+// Internal declaration path used by @farm.js/core root type re-exports.
+declare module "@farm.js/core/dist/client.js" {
+  interface LinkDefaultRoute {
+    _: import(${JSON.stringify(routeTypesImportPath)}).RoutePath;
+    pattern: import(${JSON.stringify(routeTypesImportPath)}).RoutePattern;
+  }
+}
+`;
+  const routeModuleAugmentationBlock = `
+declare global {
+  namespace FarmJS {
+    interface RouteRegistry {
+      pattern: import(${JSON.stringify(routeTypesImportPath)}).RouteModulePattern;
+    }
+  }
+}
+`;
+  const content = `/**
+ * Auto-generated route types from src/app.
+ * Link href and route component props are typed automatically from generated declarations.
+ * Regenerated on dev start and when routes change.
+ * Set suppressLintOnLink: true in farm.config.ts to accept any string on Link href.
+ */
+${renderTypeAlias("RoutePath", routePathType)}
+${renderTypeAlias("RoutePattern", routePatternType)}
+${renderTypeAlias("RouteModulePattern", routeModulePatternType)}${linkAugmentationBlock}${routeModuleAugmentationBlock}
+`;
+  return content;
+}
+
+// src/image-types.ts
+
+
+var FARM_STATIC_IMAGE_EXTENSIONS = ["avif", "gif", "jpeg", "jpg", "png", "webp"];
+function generateFarmImageTypes(options) {
+  const outputPath = options.outFile ? path.default.resolve(options.root, options.outFile) : path.default.join(options.root, options.srcDir || "src", "farm-images.d.ts");
+  _fs.mkdirSync.call(void 0, path.default.dirname(outputPath), { recursive: true });
+  _chunk5YPBFMBNcjs.writeFileIfChanged.call(void 0, outputPath, createFarmImageTypeDeclarations());
+  return outputPath;
+}
+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;
+}
+`;
+}
+
+// src/i18n/type-generator.ts
+
+
+async function generateFarmI18nTypes(options) {
+  if (!options.config.enabled) return void 0;
+  const { signatures } = await _chunkBBPDJGCUcjs.readFarmI18nCatalogs.call(void 0, options.config);
+  const outFile = options.outFile ? _path.resolve.call(void 0, options.root, options.outFile) : _path.join.call(void 0, _path.resolve.call(void 0, options.root), options.srcDir || "src", "farm-i18n.d.ts");
+  const content = renderFarmI18nTypes(options.config.locales, signatures);
+  _fs.mkdirSync.call(void 0, _path.dirname.call(void 0, outFile), { recursive: true });
+  _chunk5YPBFMBNcjs.writeFileIfChanged.call(void 0, outFile, content);
+  return outFile;
+}
+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 {};
+`;
+}
+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("; ")} }`;
+}
+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";
+  }
+}
+
+// src/type-artifacts.ts
+
+
+
+// src/content-types.ts
+
+
+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 = [
+    ...(_nullishCoalesce(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 {};
+`;
+}
+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 {};
+`;
+}
+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;
+}
+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}`;
+}
+
+// src/schema-model-types.ts
+function createSyncModelTypeDeclarations(plugins) {
+  const rowEntries = [];
+  const insertEntries = [];
+  for (const plugin of _nullishCoalesce(plugins, () => ( []))) {
+    const declaration = _chunkSYW346ZNcjs.readSchemaTables.call(void 0, plugin);
+    if (!declaration || declaration.name !== "sync") continue;
+    const exposed = declaration.models ? new Set(declaration.models) : null;
+    const models = _chunkGBMWLDCCcjs.resolveSchemaModels.call(void 0, 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")}
+  }
+}`;
+}
+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")}
+    };`;
+}
+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 _optionalChain([field, 'access', _41 => _41.values, 'optionalAccess', _42 => _42.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}[]`;
+}
+function isCursorField(fieldKey, field) {
+  return field.type === "datetime" && (fieldKey === "updatedAt" || field.name === "updated_at");
+}
+function propertyName(key) {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
+}
+
+// src/type-artifacts.ts
+async function generateFarmTypeArtifacts(options) {
+  const root = _path.resolve.call(void 0, 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 && _optionalChain([options, 'access', _43 => _43.i18nConfig, 'optionalAccess', _44 => _44.enabled]);
+  const sourceRoots = _chunk5Y2P454Ocjs.getFarmSourceRoots.call(void 0, { root, srcDir, layers: options.layers });
+  const appDirs = _chunk5Y2P454Ocjs.getFarmAppDirectories.call(void 0, { root, srcDir, layers: options.layers });
+  const result = {
+    apiRoutes: [],
+    stalePaths: []
+  };
+  const unifiedTypesPath = _path.join.call(void 0, 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 (0, _chunkQISW423Scjs.APITypeGenerator)(appDirs);
+    const apiRoutes = generator.scanAPIRoutes();
+    const apiTypesPath = options.apiTypesOutFile ? _path.resolve.call(void 0, root, options.apiTypesOutFile) : _path.join.call(void 0, root, srcDir, "lib", "api.generated.ts");
+    const pluginRoutes = _chunk5C7XMKQ4cjs.resolvePluginRoutes.call(void 0, options.plugins);
+    const configFiles = [
+      ...(_nullishCoalesce(options.layers, () => ( []))).map((layer) => layer.configFile).filter((file) => Boolean(file)),
+      options.configPath ? _path.resolve.call(void 0, 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) => _path.join.call(void 0, root, name)).find((file) => _fs.existsSync.call(void 0, 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 || _fs.existsSync.call(void 0, 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(
+      _chunkGSVJ3IIFcjs.createEnvTypeDeclarations.call(void 0, 
+        {
+          root,
+          srcDir,
+          configPath: options.configPath,
+          layerConfigPaths: (_nullishCoalesce(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: (_nullishCoalesce(options.layers, () => ( []))).map((layer) => layer.configFile).filter((configFile) => Boolean(configFile))
+    };
+    if (options.check) {
+      const envTypesPath = resolveGeneratedPath(root, srcDir, options.envTypesOutFile);
+      checkGeneratedFile(
+        envTypesPath,
+        _chunkGSVJ3IIFcjs.createEnvTypeDeclarations.call(void 0, envOptions, envTypesPath),
+        result.stalePaths
+      );
+      result.envTypesPath = envTypesPath;
+    } else {
+      result.envTypesPath = await _chunkGSVJ3IIFcjs.generateEnvTypes.call(void 0, 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 && _optionalChain([options, 'access', _45 => _45.i18nConfig, 'optionalAccess', _46 => _46.enabled]) && !options.i18nTypesOutFile) {
+    const { signatures } = await _chunkBBPDJGCUcjs.readFarmI18nCatalogs.call(void 0, 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 _chunkBBPDJGCUcjs.readFarmI18nCatalogs.call(void 0, 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: (_nullishCoalesce(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;
+}
+function normalizeUnifiedTypeSection(section) {
+  return section.trimEnd().replace(/\n+export \{\};$/, "");
+}
+function resolveGeneratedPath(root, srcDir, outFile, relativeToSrc = true) {
+  if (_path.isAbsolute.call(void 0, outFile)) return _path.resolve.call(void 0, outFile);
+  return _path.resolve.call(void 0, root, relativeToSrc ? _path.join.call(void 0, srcDir, outFile) : outFile);
+}
+function writeOrCheckGeneratedFile(filePath, content, check, stalePaths) {
+  if (check) {
+    checkGeneratedFile(filePath, content, stalePaths);
+    return;
+  }
+  _fs.mkdirSync.call(void 0, _path.dirname.call(void 0, filePath), { recursive: true });
+  _chunk5YPBFMBNcjs.writeFileIfChanged.call(void 0, filePath, content);
+}
+function checkGeneratedFile(filePath, content, stalePaths) {
+  if (!_fs.existsSync.call(void 0, filePath) || _fs.readFileSync.call(void 0, filePath, "utf8") !== content) {
+    stalePaths.push(filePath);
+  }
+}
+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 = _path.join.call(void 0, root, srcDir, fileName);
+    if (!_fs.existsSync.call(void 0, filePath)) continue;
+    const source = _fs.readFileSync.call(void 0, filePath, "utf8");
+    if (source.includes(marker)) {
+      _fs.unlinkSync.call(void 0, filePath);
+    }
+  }
+}
+function collectLegacyTypeArtifacts(root, srcDir, stalePaths) {
+  for (const [fileName, marker] of LEGACY_TYPE_ARTIFACTS) {
+    const filePath = _path.join.call(void 0, root, srcDir, fileName);
+    if (!_fs.existsSync.call(void 0, filePath)) continue;
+    if (_fs.readFileSync.call(void 0, filePath, "utf8").includes(marker)) stalePaths.push(filePath);
+  }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.resolveRouteRenderingConfig = resolveRouteRenderingConfig; exports.resolveRouteRenderingConfigFromFile = resolveRouteRenderingConfigFromFile; exports.analyzeStaticRouteCandidate = analyzeStaticRouteCandidate; exports.findRequestBoundSourceBlockers = findRequestBoundSourceBlockers; exports.parseRouteRenderingDirective = parseRouteRenderingDirective; exports.readRouteRenderingDirectiveFromFile = readRouteRenderingDirectiveFromFile; exports.collectSSGPages = collectSSGPages; exports.isSSGModule = isSSGModule; exports.hasISR = hasISR; exports.getRevalidateInterval = getRevalidateInterval; exports.hasPPR = hasPPR; exports.generateSSGManifest = generateSSGManifest; exports.matchSSGPage = matchSSGPage; exports.generateRouteTypes = generateRouteTypes; exports.generateFarmImageTypes = generateFarmImageTypes; exports.createFarmImageTypeDeclarations = createFarmImageTypeDeclarations; exports.generateFarmI18nTypes = generateFarmI18nTypes; exports.generateFarmTypeArtifacts = generateFarmTypeArtifacts;