@farm.js/core 0.1.14 → 0.1.16

package/dist/vite.cjs

@@ -31,6 +31,212 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/env.ts
+function createBundledEnv(env2, source = getProcessEnv()) {
+  const resolved = normalizeResolvedEnv(env2 ?? {});
+  const server = {};
+  const runtime3 = {};
+  for (const [key, value] of Object.entries(resolved.server)) {
+    if (source[key] === void 0) {
+      server[key] = value;
+    } else {
+      runtime3[key] = getRuntimeEnvType(value);
+    }
+  }
+  return {
+    server,
+    public: resolved.public,
+    ...Object.keys(runtime3).length > 0 ? { runtime: { server: runtime3 } } : {}
+  };
+}
+function createEnvProxy(scope) {
+  return new Proxy(
+    {},
+    {
+      get(_target, property) {
+        if (typeof property === "symbol") {
+          return void 0;
+        }
+        const env2 = getEnvScope(scope);
+        return scope === "server" ? readServerEnvKey(env2, property) : env2[property];
+      },
+      ownKeys() {
+        return Reflect.ownKeys(getEnvScope(scope));
+      },
+      getOwnPropertyDescriptor(_target, property) {
+        const env2 = getEnvScope(scope);
+        if (!(property in env2)) {
+          return void 0;
+        }
+        return {
+          enumerable: true,
+          configurable: true,
+          value: env2[property]
+        };
+      },
+      has(_target, property) {
+        return property in getEnvScope(scope);
+      }
+    }
+  );
+}
+function getEnvScope(scope) {
+  const env2 = getCurrentEnv();
+  if (scope === "server") {
+    assertServerEnvAccess();
+    readRuntimeServerEnv(env2);
+  }
+  return env2[scope] || {};
+}
+function readServerEnvKey(server, key) {
+  const value = server[key];
+  if (value === void 0) {
+    const state = getCurrentEnv()[FARM_ENV_RUNTIME_SYMBOL];
+    if (state && key in state.pending && !state.warned.has(key)) {
+      state.warned.add(key);
+      console.warn(
+        `[Farm] Server env "${key}" was set when this app was built but is not set where the server runs, so it reads as undefined. Farm reads server env at runtime and does not store it in the build output; set "${key}" in the server's environment.`
+      );
+    }
+  }
+  return value;
+}
+function readRuntimeServerEnv(env2) {
+  const state = env2[FARM_ENV_RUNTIME_SYMBOL];
+  if (!state) return;
+  const source = getProcessEnv();
+  for (const [key, type] of Object.entries(state.pending)) {
+    const raw = source[key];
+    if (raw === void 0) continue;
+    env2.server[key] = coerceRuntimeEnvValue(raw, type);
+    delete state.pending[key];
+  }
+}
+function getRuntimeEnvType(value) {
+  if (typeof value === "number") return "number";
+  if (typeof value === "boolean") return "boolean";
+  if (value !== null && typeof value === "object" && !(value instanceof Date)) return "json";
+  return "string";
+}
+function coerceRuntimeEnvValue(raw, type) {
+  if (type === "number") {
+    const value = Number(raw);
+    return raw.trim() !== "" && Number.isFinite(value) ? value : raw;
+  }
+  if (type === "boolean") {
+    if (/^(true|1)$/i.test(raw.trim())) return true;
+    if (/^(false|0|)$/i.test(raw.trim())) return false;
+    return raw;
+  }
+  if (type === "json") {
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return raw;
+    }
+  }
+  return raw;
+}
+function prepareEnv(env2) {
+  const normalized = normalizeResolvedEnv(env2);
+  const runtime3 = env2.runtime?.server;
+  if (!isRecord(runtime3) || Object.keys(runtime3).length === 0) return normalized;
+  const prepared = { server: { ...normalized.server }, public: normalized.public };
+  Object.defineProperty(prepared, FARM_ENV_RUNTIME_SYMBOL, {
+    value: {
+      pending: { ...runtime3 },
+      warned: /* @__PURE__ */ new Set()
+    },
+    enumerable: false
+  });
+  return prepared;
+}
+function assertServerEnvAccess() {
+  if (typeof window !== "undefined") {
+    throw new Error("Farm server env is not available in the browser. Use publicEnv.");
+  }
+}
+function getInitialEnv() {
+  const injectedEnv = getInjectedEnv();
+  if (injectedEnv) {
+    return injectedEnv;
+  }
+  if (typeof window === "undefined" && farmEnvGlobal[FARM_ENV_SYMBOL]) {
+    return normalizeResolvedEnv(farmEnvGlobal[FARM_ENV_SYMBOL]);
+  }
+  return {
+    server: {},
+    public: getInjectedPublicEnv()
+  };
+}
+function getCurrentEnv() {
+  if (typeof window === "undefined" && farmEnvGlobal[FARM_ENV_SYMBOL]) {
+    return farmEnvGlobal[FARM_ENV_SYMBOL];
+  }
+  return currentEnv;
+}
+function getInjectedEnv() {
+  try {
+    if (typeof __FARM_ENV__ !== "undefined" && __FARM_ENV__) {
+      return prepareEnv(__FARM_ENV__);
+    }
+  } catch {
+  }
+  return null;
+}
+function getInjectedPublicEnv() {
+  try {
+    if (typeof __FARM_PUBLIC_ENV__ !== "undefined" && __FARM_PUBLIC_ENV__) {
+      return __FARM_PUBLIC_ENV__;
+    }
+  } catch {
+  }
+  return {};
+}
+function normalizeResolvedEnv(env2) {
+  return {
+    server: isRecord(env2.server) ? env2.server : {},
+    public: isRecord(env2.public) ? env2.public : {}
+  };
+}
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function getProcessEnv() {
+  if (typeof process !== "undefined" && process.env) {
+    return process.env;
+  }
+  return {};
+}
+var FARM_ENV_SYMBOL, FARM_ENV_RUNTIME_SYMBOL, farmEnvGlobal, currentEnv, env, publicEnv;
+var init_env = __esm({
+  "src/env.ts"() {
+    "use strict";
+    FARM_ENV_SYMBOL = /* @__PURE__ */ Symbol.for("farm.env");
+    FARM_ENV_RUNTIME_SYMBOL = /* @__PURE__ */ Symbol.for("farm.env.runtime");
+    farmEnvGlobal = globalThis;
+    currentEnv = getInitialEnv();
+    __name(createBundledEnv, "createBundledEnv");
+    env = createEnvProxy("server");
+    publicEnv = createEnvProxy("public");
+    __name(createEnvProxy, "createEnvProxy");
+    __name(getEnvScope, "getEnvScope");
+    __name(readServerEnvKey, "readServerEnvKey");
+    __name(readRuntimeServerEnv, "readRuntimeServerEnv");
+    __name(getRuntimeEnvType, "getRuntimeEnvType");
+    __name(coerceRuntimeEnvValue, "coerceRuntimeEnvValue");
+    __name(prepareEnv, "prepareEnv");
+    __name(assertServerEnvAccess, "assertServerEnvAccess");
+    __name(getInitialEnv, "getInitialEnv");
+    __name(getCurrentEnv, "getCurrentEnv");
+    __name(getInjectedEnv, "getInjectedEnv");
+    __name(getInjectedPublicEnv, "getInjectedPublicEnv");
+    __name(normalizeResolvedEnv, "normalizeResolvedEnv");
+    __name(isRecord, "isRecord");
+    __name(getProcessEnv, "getProcessEnv");
+  }
+});
+
 // src/app-markdown-config.ts
 function resolveMdxConfig(config) {
   return {
@@ -8942,7 +9148,7 @@ function serializeFarmLlmsTxt(value) {
     return value.endsWith("\n") ? value : `${value}
 `;
   }
-  if (!isRecord2(value)) {
+  if (!isRecord3(value)) {
     throw new TypeError("llms.ts must return llms.txt text, an llms.txt object, or a Response");
   }
   const title = requireText(value.title, "llms.ts must return a non-empty title");
@@ -8955,7 +9161,7 @@ function serializeFarmLlmsTxt(value) {
   if (summary?.trim()) blocks.push(`> ${toSingleLine(summary)}`);
   if (details?.trim()) blocks.push(details.trim());
   for (const [sectionIndex, section] of (value.sections ?? []).entries()) {
-    if (!isRecord2(section)) {
+    if (!isRecord3(section)) {
       throw new TypeError(`llms.ts section ${sectionIndex} must be an object`);
     }
     const sectionTitle = requireText(
@@ -8967,7 +9173,7 @@ function serializeFarmLlmsTxt(value) {
     }
     const links = section.links.map((link, linkIndex) => {
       const where = `llms.ts section "${sectionTitle}" link ${linkIndex}`;
-      if (!isRecord2(link)) throw new TypeError(`${where} must be an object`);
+      if (!isRecord3(link)) throw new TypeError(`${where} must be an object`);
       const linkTitle = requireText(link.title, `${where} must include a non-empty title`);
       const url = requireText(link.url, `${where} must include a non-empty url`);
       const description = optionalText(link.description, `${where} description must be a string`);
@@ -9053,10 +9259,10 @@ async function mapWithConcurrency(items, limit, run) {
   return results;
 }
 function readMetadataTitle(metadata) {
-  if (!isRecord2(metadata)) return void 0;
+  if (!isRecord3(metadata)) return void 0;
   const { title } = metadata;
   if (typeof title === "string") return title.trim() || void 0;
-  if (isRecord2(title)) {
+  if (isRecord3(title)) {
     for (const key of ["absolute", "default"]) {
       const value = title[key];
       if (typeof value === "string" && value.trim()) return value.trim();
@@ -9065,7 +9271,7 @@ function readMetadataTitle(metadata) {
   return void 0;
 }
 function readMetadataString(metadata, key) {
-  if (!isRecord2(metadata)) return void 0;
+  if (!isRecord3(metadata)) return void 0;
   const value = metadata[key];
   return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
@@ -9097,7 +9303,7 @@ function optionalText(value, message) {
   if (typeof value !== "string") throw new TypeError(message);
   return value;
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 var init_llms_txt = __esm({
@@ -9123,7 +9329,7 @@ var init_llms_txt = __esm({
     __name(escapeLinkUrl, "escapeLinkUrl");
     __name(requireText, "requireText");
     __name(optionalText, "optionalText");
-    __name(isRecord2, "isRecord");
+    __name(isRecord3, "isRecord");
   }
 });
 
@@ -10346,116 +10552,6 @@ var init_config3 = __esm({
   }
 });
 
-// src/env.ts
-function createEnvProxy(scope) {
-  return new Proxy(
-    {},
-    {
-      get(_target, property) {
-        if (typeof property === "symbol") {
-          return void 0;
-        }
-        const env2 = getEnvScope(scope);
-        return env2[property];
-      },
-      ownKeys() {
-        return Reflect.ownKeys(getEnvScope(scope));
-      },
-      getOwnPropertyDescriptor(_target, property) {
-        const env2 = getEnvScope(scope);
-        if (!(property in env2)) {
-          return void 0;
-        }
-        return {
-          enumerable: true,
-          configurable: true,
-          value: env2[property]
-        };
-      },
-      has(_target, property) {
-        return property in getEnvScope(scope);
-      }
-    }
-  );
-}
-function getEnvScope(scope) {
-  if (scope === "server") {
-    assertServerEnvAccess();
-  }
-  return getCurrentEnv()[scope] || {};
-}
-function assertServerEnvAccess() {
-  if (typeof window !== "undefined") {
-    throw new Error("Farm server env is not available in the browser. Use publicEnv.");
-  }
-}
-function getInitialEnv() {
-  const injectedEnv = getInjectedEnv();
-  if (injectedEnv) {
-    return injectedEnv;
-  }
-  if (typeof window === "undefined" && farmEnvGlobal[FARM_ENV_SYMBOL]) {
-    return normalizeResolvedEnv(farmEnvGlobal[FARM_ENV_SYMBOL]);
-  }
-  return {
-    server: {},
-    public: getInjectedPublicEnv()
-  };
-}
-function getCurrentEnv() {
-  if (typeof window === "undefined" && farmEnvGlobal[FARM_ENV_SYMBOL]) {
-    return farmEnvGlobal[FARM_ENV_SYMBOL];
-  }
-  return currentEnv;
-}
-function getInjectedEnv() {
-  try {
-    if (typeof __FARM_ENV__ !== "undefined" && __FARM_ENV__) {
-      return normalizeResolvedEnv(__FARM_ENV__);
-    }
-  } catch {
-  }
-  return null;
-}
-function getInjectedPublicEnv() {
-  try {
-    if (typeof __FARM_PUBLIC_ENV__ !== "undefined" && __FARM_PUBLIC_ENV__) {
-      return __FARM_PUBLIC_ENV__;
-    }
-  } catch {
-  }
-  return {};
-}
-function normalizeResolvedEnv(env2) {
-  return {
-    server: isRecord4(env2.server) ? env2.server : {},
-    public: isRecord4(env2.public) ? env2.public : {}
-  };
-}
-function isRecord4(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value);
-}
-var FARM_ENV_SYMBOL, farmEnvGlobal, currentEnv, env, publicEnv;
-var init_env = __esm({
-  "src/env.ts"() {
-    "use strict";
-    FARM_ENV_SYMBOL = /* @__PURE__ */ Symbol.for("farm.env");
-    farmEnvGlobal = globalThis;
-    currentEnv = getInitialEnv();
-    env = createEnvProxy("server");
-    publicEnv = createEnvProxy("public");
-    __name(createEnvProxy, "createEnvProxy");
-    __name(getEnvScope, "getEnvScope");
-    __name(assertServerEnvAccess, "assertServerEnvAccess");
-    __name(getInitialEnv, "getInitialEnv");
-    __name(getCurrentEnv, "getCurrentEnv");
-    __name(getInjectedEnv, "getInjectedEnv");
-    __name(getInjectedPublicEnv, "getInjectedPublicEnv");
-    __name(normalizeResolvedEnv, "normalizeResolvedEnv");
-    __name(isRecord4, "isRecord");
-  }
-});
-
 // src/plugin-dependencies.ts
 function pluginShortName(name2) {
   return name2.slice(Math.max(name2.lastIndexOf(":"), name2.lastIndexOf("/")) + 1);
@@ -17453,6 +17549,7 @@ __export(vite_exports, {
   withFarmRequestTracing: () => withFarmRequestTracing
 });
 module.exports = __toCommonJS(vite_exports);
+init_env();
 
 // src/app.ts
 init_app_markdown_config();
@@ -19260,9 +19357,10 @@ function collectIsolatedClientBoundaries(ownerPath, root, options = {}) {
     const importedBindings = getStaticImportBindings(content);
     let estimatedBoundaryCount2 = 0;
     for (const specifier of new Set(getImportSpecifiers(content))) {
-      const importedPath = resolveImportedModuleSourcePath(moduleSourcePath, specifier, root);
+      const imported = resolveImportedModule(moduleSourcePath, specifier, root);
+      const importedPath = imported.path;
       if (!importedPath) continue;
-      if (!specifier.startsWith(".") && !specifier.startsWith("/")) {
+      if (!imported.local) {
         const packageMetadata = inspectPackageClientBoundary(importedPath, root, /* @__PURE__ */ new Set());
         if (packageMetadata.shouldHydrate) {
           if (options.staticPackageBoundaries) {
@@ -19331,8 +19429,8 @@ function inspectClientModuleMetadata(resolvedPath, root, visited, inspectIslandE
   let importsClientBoundary = false;
   let importedIslandStrategy = null;
   for (const specifier of getImportSpecifiers(content)) {
-    const importedPath = resolveImportedModuleSourcePath(resolvedPath, specifier, root);
-    const importedMetadata = !specifier.startsWith(".") && !specifier.startsWith("/") ? inspectPackageClientBoundary(importedPath, root, visited) : inspectClientModuleMetadata(importedPath, root, visited, false);
+    const imported = resolveImportedModule(resolvedPath, specifier, root);
+    const importedMetadata = imported.local ? inspectClientModuleMetadata(imported.path, root, visited, false) : inspectPackageClientBoundary(imported.path, root, visited);
     if (importedMetadata.isClientComponent || importedMetadata.shouldHydrate) {
       importsClientBoundary = true;
       if (importedIslandStrategy === null) {
@@ -19461,6 +19559,171 @@ function isTypeOnlyNamedClause(tokens, startIndex, endIndex) {
   return true;
 }
 __name(isTypeOnlyNamedClause, "isTypeOnlyNamedClause");
+function resolveImportedModule(importerPath, specifier, root) {
+  if (specifier.startsWith(".") || specifier.startsWith("/")) {
+    return { path: resolveImportedModuleSourcePath(importerPath, specifier, root), local: true };
+  }
+  const aliased = resolveProjectAliasSourcePath(specifier, root);
+  if (aliased !== void 0) return { path: aliased, local: true };
+  return { path: resolvePackageModuleSourcePath(importerPath, specifier, root), local: false };
+}
+__name(resolveImportedModule, "resolveImportedModule");
+var projectImportAliasCache = /* @__PURE__ */ new Map();
+var PROJECT_ALIAS_FILES = ["tsconfig.json", "jsconfig.json", "package.json"];
+function resolveProjectAliasSourcePath(specifier, root) {
+  if (!root) return void 0;
+  const projectRoot = import_path4.default.resolve(root);
+  let match;
+  for (const alias of getProjectImportAliases(projectRoot)) {
+    const captured = matchProjectImportAlias(alias, specifier);
+    if (captured === null) continue;
+    if (!match || alias.prefix.length > match.alias.prefix.length) match = { alias, captured };
+  }
+  if (!match) return void 0;
+  return resolveSourceCandidate(
+    match.alias.targets.map(
+      (target) => import_path4.default.normalize(match.alias.wildcard ? target.replace("*", match.captured) : target)
+    )
+  );
+}
+__name(resolveProjectAliasSourcePath, "resolveProjectAliasSourcePath");
+function matchProjectImportAlias(alias, specifier) {
+  if (!alias.wildcard) return specifier === alias.prefix ? "" : null;
+  if (specifier.length < alias.prefix.length + alias.suffix.length || !specifier.startsWith(alias.prefix) || !specifier.endsWith(alias.suffix)) {
+    return null;
+  }
+  return specifier.slice(alias.prefix.length, specifier.length - alias.suffix.length);
+}
+__name(matchProjectImportAlias, "matchProjectImportAlias");
+function getProjectImportAliases(projectRoot) {
+  const stamp = PROJECT_ALIAS_FILES.map((file) => {
+    try {
+      return String(import_fs2.default.statSync(import_path4.default.join(projectRoot, file)).mtimeMs);
+    } catch {
+      return "-";
+    }
+  }).join(":");
+  const cached = projectImportAliasCache.get(projectRoot);
+  if (cached?.stamp === stamp) return cached.aliases;
+  const aliases = [
+    ...readTsconfigPathAliases(projectRoot),
+    ...readPackageImportAliases(projectRoot)
+  ];
+  if (!aliases.some((alias) => alias.prefix === "@/")) {
+    aliases.push({
+      prefix: "@/",
+      suffix: "",
+      wildcard: true,
+      targets: [import_path4.default.join(projectRoot, "src", "*")]
+    });
+  }
+  projectImportAliasCache.set(projectRoot, { stamp, aliases });
+  return aliases;
+}
+__name(getProjectImportAliases, "getProjectImportAliases");
+function readTsconfigPathAliases(projectRoot) {
+  for (const name2 of ["tsconfig.json", "jsconfig.json"]) {
+    const configPath = import_path4.default.join(projectRoot, name2);
+    if (!import_fs2.default.existsSync(configPath)) continue;
+    const resolved = readTsconfigPaths(configPath, /* @__PURE__ */ new Set());
+    if (!resolved?.paths) return [];
+    const base = resolved.baseUrl ?? resolved.pathsDirectory;
+    return Object.entries(resolved.paths).flatMap(([pattern, targets]) => {
+      if (!Array.isArray(targets)) return [];
+      const wildcardIndex = pattern.indexOf("*");
+      return [
+        {
+          prefix: wildcardIndex === -1 ? pattern : pattern.slice(0, wildcardIndex),
+          suffix: wildcardIndex === -1 ? "" : pattern.slice(wildcardIndex + 1),
+          wildcard: wildcardIndex !== -1,
+          targets: targets.filter((target) => typeof target === "string").map((target) => import_path4.default.resolve(base, target))
+        }
+      ];
+    });
+  }
+  return [];
+}
+__name(readTsconfigPathAliases, "readTsconfigPathAliases");
+function readTsconfigPaths(configPath, visited) {
+  if (visited.has(configPath)) return null;
+  visited.add(configPath);
+  const config = readJsonWithComments(configPath);
+  if (!config) return null;
+  const directory = import_path4.default.dirname(configPath);
+  const parents = (Array.isArray(config.extends) ? config.extends : [config.extends]).filter(
+    (parent) => typeof parent === "string" && parent.startsWith(".")
+  );
+  let inherited = null;
+  for (const parent of parents) {
+    const parentPath = import_path4.default.resolve(
+      directory,
+      parent.endsWith(".json") ? parent : `${parent}.json`
+    );
+    inherited = readTsconfigPaths(parentPath, visited) ?? inherited;
+  }
+  const options = config.compilerOptions ?? {};
+  const baseUrl = typeof options.baseUrl === "string" ? import_path4.default.resolve(directory, options.baseUrl) : inherited?.baseUrl;
+  if (options.paths && typeof options.paths === "object") {
+    return { paths: options.paths, pathsDirectory: directory, baseUrl };
+  }
+  return inherited ? { ...inherited, baseUrl } : { pathsDirectory: directory, baseUrl };
+}
+__name(readTsconfigPaths, "readTsconfigPaths");
+function readPackageImportAliases(projectRoot) {
+  const imports = readPackageJson(import_path4.default.join(projectRoot, "package.json"))?.imports;
+  if (!imports || typeof imports !== "object") return [];
+  return Object.entries(imports).flatMap(([pattern, value]) => {
+    const target = resolveConditionalExportTarget(value);
+    if (!pattern.startsWith("#") || !target?.startsWith("./")) return [];
+    const wildcardIndex = pattern.indexOf("*");
+    return [
+      {
+        prefix: wildcardIndex === -1 ? pattern : pattern.slice(0, wildcardIndex),
+        suffix: wildcardIndex === -1 ? "" : pattern.slice(wildcardIndex + 1),
+        wildcard: wildcardIndex !== -1,
+        targets: [import_path4.default.resolve(projectRoot, target)]
+      }
+    ];
+  });
+}
+__name(readPackageImportAliases, "readPackageImportAliases");
+function readJsonWithComments(filePath) {
+  let source;
+  try {
+    source = import_fs2.default.readFileSync(filePath, "utf8");
+  } catch {
+    return null;
+  }
+  let output = "";
+  let inString = false;
+  for (let index = 0; index < source.length; index++) {
+    const char = source[index];
+    if (inString) {
+      output += char;
+      if (char === "\\") output += source[++index] ?? "";
+      else if (char === '"') inString = false;
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+      output += char;
+    } else if (char === "/" && source[index + 1] === "/") {
+      while (index < source.length && source[index] !== "\n") index++;
+      output += "\n";
+    } else if (char === "/" && source[index + 1] === "*") {
+      const end = source.indexOf("*/", index + 2);
+      index = end === -1 ? source.length : end + 1;
+    } else {
+      output += char;
+    }
+  }
+  try {
+    return JSON.parse(output.replace(/,(\s*[}\]])/g, "$1"));
+  } catch {
+    return null;
+  }
+}
+__name(readJsonWithComments, "readJsonWithComments");
 function resolveImportedModuleSourcePath(importerPath, specifier, root) {
   if (!specifier.startsWith(".") && !specifier.startsWith("/")) {
     return resolvePackageModuleSourcePath(importerPath, specifier, root);
@@ -21304,11 +21567,11 @@ function mergeMetadata(base, next) {
 __name(mergeMetadata, "mergeMetadata");
 function mergeMetadataTitle(base, next) {
   if (next === void 0) return base;
-  const parentTemplate = isRecord(base) ? normalizeContent(base.template) : void 0;
+  const parentTemplate = isRecord2(base) ? normalizeContent(base.template) : void 0;
   if (typeof next === "string") {
     return parentTemplate ? applyTitleTemplate(parentTemplate, next) : next;
   }
-  if (!isRecord(next)) return next;
+  if (!isRecord2(next)) return next;
   const defaultTitle = normalizeContent(next.default) ?? resolveMetadataTitle(base);
   return {
     ...next,
@@ -21359,8 +21622,8 @@ __name(addMetadataImageReference, "addMetadataImageReference");
 var MARKDOWN_MIME_TYPE = "text/markdown";
 function addMetadataMarkdownAlternate(metadata, href) {
   if (!href) return metadata;
-  const alternates = isRecord(metadata.alternates) ? metadata.alternates : {};
-  const types = isRecord(alternates.types) ? alternates.types : {};
+  const alternates = isRecord2(metadata.alternates) ? metadata.alternates : {};
+  const types = isRecord2(alternates.types) ? alternates.types : {};
   if (Object.keys(types).some((type) => type.toLowerCase() === MARKDOWN_MIME_TYPE)) {
     return metadata;
   }
@@ -21393,26 +21656,26 @@ function renderMetadataHead(metadata, options = {}) {
   appendMetaName(tags, "creator", resolvedMetadata.creator);
   appendMetaName(tags, "publisher", resolvedMetadata.publisher);
   appendMetaName(tags, "robots", normalizeRobots(resolvedMetadata.robots));
-  if (isRecord(resolvedMetadata.robots)) {
+  if (isRecord2(resolvedMetadata.robots)) {
     appendMetaName(tags, "googlebot", normalizeRobots(resolvedMetadata.robots.googleBot));
   }
   const alternates = resolvedMetadata.alternates;
-  const explicitCanonical = isRecord(alternates) ? alternates.canonical : void 0;
+  const explicitCanonical = isRecord2(alternates) ? alternates.canonical : void 0;
   const canonicalHref = explicitCanonical != null ? resolveMetadataUrl(explicitCanonical, metadataBase) : options.pathname ? resolveMetadataUrl(sanitizeSelfCanonicalPathname(options.pathname), metadataBase) : void 0;
   if (canonicalHref) {
     appendLink(tags, "canonical", canonicalHref);
   }
-  if (isRecord(alternates) && isRecord(alternates.languages)) {
+  if (isRecord2(alternates) && isRecord2(alternates.languages)) {
     for (const [language, href] of Object.entries(alternates.languages)) {
       appendLink(tags, "alternate", resolveMetadataUrl(href, metadataBase), {
         hreflang: language
       });
     }
   }
-  if (isRecord(alternates) && isRecord(alternates.types)) {
+  if (isRecord2(alternates) && isRecord2(alternates.types)) {
     for (const [type, value] of Object.entries(alternates.types)) {
       for (const entry of normalizeArray(value)) {
-        const link = isRecord(entry) ? entry : { url: entry };
+        const link = isRecord2(entry) ? entry : { url: entry };
         appendLink(tags, "alternate", resolveMetadataUrl(link.url, metadataBase), {
           type,
           title: link.title
@@ -21436,14 +21699,14 @@ function renderMetadataHead(metadata, options = {}) {
     const jsonLdConfig = options.jsonLd === true ? {} : options.jsonLd;
     const jsonLdScript = renderFarmAgentJsonLd(jsonLdConfig, {
       metadataBase,
-      siteName: isRecord(resolvedMetadata.openGraph) ? normalizeContent(resolvedMetadata.openGraph.siteName) : void 0,
+      siteName: isRecord2(resolvedMetadata.openGraph) ? normalizeContent(resolvedMetadata.openGraph.siteName) : void 0,
       title: explicitTitle,
       description: normalizeContent(resolvedMetadata.description)
     });
     if (jsonLdScript) tags.push(jsonLdScript);
   }
   for (const entry of normalizeArray(resolvedMetadata.jsonLd)) {
-    if (!isRecord(entry)) continue;
+    if (!isRecord2(entry)) continue;
     tags.push(
       `<script type="application/ld+json" ${FARM_METADATA_ATTRIBUTE}>${serializeJsonLd(entry)}</script>`
     );
@@ -21458,7 +21721,7 @@ function renderMetadataHead(metadata, options = {}) {
 }
 __name(renderMetadataHead, "renderMetadataHead");
 function mergeNestedMetadata(base, next) {
-  if (isRecord(base) && isRecord(next)) {
+  if (isRecord2(base) && isRecord2(next)) {
     return {
       ...base,
       ...next
@@ -21468,7 +21731,7 @@ function mergeNestedMetadata(base, next) {
 }
 __name(mergeNestedMetadata, "mergeNestedMetadata");
 function appendOpenGraph(tags, openGraph, metadataBase) {
-  if (!isRecord(openGraph)) return;
+  if (!isRecord2(openGraph)) return;
   appendMetaProperty(tags, "og:title", openGraph.title);
   appendMetaProperty(tags, "og:description", openGraph.description);
   appendMetaProperty(tags, "og:url", resolveMetadataUrl(openGraph.url, metadataBase));
@@ -21500,7 +21763,7 @@ function appendOpenGraph(tags, openGraph, metadataBase) {
 }
 __name(appendOpenGraph, "appendOpenGraph");
 function appendTwitter(tags, twitter, metadataBase) {
-  if (!isRecord(twitter)) return;
+  if (!isRecord2(twitter)) return;
   appendMetaName(tags, "twitter:card", twitter.card);
   appendMetaName(tags, "twitter:site", twitter.site);
   appendMetaName(tags, "twitter:creator", twitter.creator);
@@ -21513,7 +21776,7 @@ function appendTwitter(tags, twitter, metadataBase) {
 }
 __name(appendTwitter, "appendTwitter");
 function appendNamedMetaRecord(tags, record) {
-  if (!isRecord(record)) return;
+  if (!isRecord2(record)) return;
   for (const [name2, value] of Object.entries(record)) {
     for (const content of normalizeArray(value)) {
       appendMetaName(tags, name2, content, true);
@@ -21528,7 +21791,7 @@ function appendIcons(tags, icons, metadataBase) {
     appendLink(tags, "icon", resolveMetadataUrl(icons, metadataBase));
     return tags.length > initialTagCount2;
   }
-  if (!isRecord(icons)) return false;
+  if (!isRecord2(icons)) return false;
   const initialTagCount = tags.length;
   appendIconList(tags, "icon", icons.icon, metadataBase);
   appendIconList(tags, "shortcut icon", icons.shortcut, metadataBase);
@@ -21543,7 +21806,7 @@ function appendIconList(tags, rel, value, metadataBase) {
       appendLink(tags, rel, resolveMetadataUrl(icon2, metadataBase));
       continue;
     }
-    if (!isRecord(icon2)) continue;
+    if (!isRecord2(icon2)) continue;
     appendLink(tags, rel, resolveMetadataUrl(icon2.url, metadataBase), {
       sizes: icon2.sizes,
       type: icon2.type
@@ -21574,7 +21837,7 @@ var VERIFICATION_META_NAMES = [
   ["yandex", "yandex-verification"]
 ];
 function appendVerification(tags, verification) {
-  if (!isRecord(verification)) return;
+  if (!isRecord2(verification)) return;
   for (const [key, name2] of VERIFICATION_META_NAMES) {
     for (const token of normalizeArray(verification[key])) {
       appendMetaName(tags, name2, token);
@@ -21600,7 +21863,7 @@ function normalizeMetadataImages(value, metadataBase) {
     if (typeof item === "string") {
       return { url: resolveMetadataUrl(item, metadataBase) || item };
     }
-    if (!isRecord(item)) return null;
+    if (!isRecord2(item)) return null;
     const rawUrl = item.url || item.src;
     const url = resolveMetadataUrl(rawUrl, metadataBase);
     if (!url) return null;
@@ -21625,7 +21888,7 @@ function hasMetadataImages(value) {
 __name(hasMetadataImages, "hasMetadataImages");
 function resolveMetadataTitle(title) {
   if (typeof title === "string") return title;
-  if (isRecord(title)) {
+  if (isRecord2(title)) {
     return normalizeContent(title.default);
   }
   return void 0;
@@ -21645,7 +21908,7 @@ var ROBOTS_VALUES = [
 ];
 function normalizeRobots(robots) {
   if (typeof robots === "string") return robots;
-  if (!isRecord(robots)) return void 0;
+  if (!isRecord2(robots)) return void 0;
   const values = [];
   if (typeof robots.index === "boolean") values.push(robots.index ? "index" : "noindex");
   if (typeof robots.follow === "boolean") values.push(robots.follow ? "follow" : "nofollow");
@@ -21706,10 +21969,10 @@ function normalizeContent(value) {
   return void 0;
 }
 __name(normalizeContent, "normalizeContent");
-function isRecord(value) {
+function isRecord2(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
-__name(isRecord, "isRecord");
+__name(isRecord2, "isRecord");
 function escapeText(value) {
   return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
@@ -23753,10 +24016,10 @@ function isResponse2(value) {
   ));
 }
 __name(isResponse2, "isResponse");
-function isRecord3(value) {
+function isRecord4(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
-__name(isRecord3, "isRecord");
+__name(isRecord4, "isRecord");
 function resolveCacheControl2(revalidate) {
   if (revalidate === false) {
     return "public, max-age=31536000, immutable";
@@ -23776,7 +24039,7 @@ function serializeSitemap(value) {
     throw new TypeError("sitemap.ts must return an array or a Response");
   }
   const entries = value.map((candidate, index) => {
-    if (!isRecord3(candidate) || typeof candidate.url !== "string" || !candidate.url) {
+    if (!isRecord4(candidate) || typeof candidate.url !== "string" || !candidate.url) {
       throw new TypeError(`sitemap.ts entry ${index} must include a non-empty url`);
     }
     return candidate;
@@ -23818,7 +24081,7 @@ function toArray2(value) {
 }
 __name(toArray2, "toArray");
 function serializeRobots(value) {
-  if (!isRecord3(value)) {
+  if (!isRecord4(value)) {
     throw new TypeError("robots.ts must return a robots object or a Response");
   }
   const robots = value;
@@ -23827,7 +24090,7 @@ function serializeRobots(value) {
     throw new TypeError("robots.ts must return at least one rule");
   }
   const sections = rules.map((rule, index) => {
-    if (!isRecord3(rule)) {
+    if (!isRecord4(rule)) {
       throw new TypeError(`robots.ts rule ${index} must be an object`);
     }
     const userAgents = toArray2(rule.userAgent).filter(
@@ -23851,7 +24114,7 @@ function serializeRobots(value) {
 }
 __name(serializeRobots, "serializeRobots");
 function serializeManifest(value) {
-  if (!isRecord3(value)) {
+  if (!isRecord4(value)) {
     throw new TypeError("manifest.ts must return a manifest object or a Response");
   }
   return `${JSON.stringify(value, null, 2)}
@@ -24913,7 +25176,7 @@ _setFarmThemeServerSnapshotResolver(() => {
 });
 
 // package.json
-var version = "0.1.14";
+var version = "0.1.16";
 
 // src/version.ts
 var FARM_VERSION = version;
@@ -32926,7 +33189,7 @@ function getEnvDefines(config, configEnv) {
     )
   };
   if (configEnv?.isSsrBuild) {
-    defines.__FARM_ENV__ = JSON.stringify(getFullEnvDefine(config));
+    defines.__FARM_ENV__ = JSON.stringify(createBundledEnv(getFullEnvDefine(config)));
   }
   return defines;
 }