@farm.js/core 0.1.14 → 0.1.16

package/dist/internal/build-runtime.cjs

@@ -31,6 +31,259 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/env.ts
+function resolveEnv(config, source = getProcessEnv()) {
+  const resolved = {
+    server: resolveEnvScope(config?.server, source, "server"),
+    public: resolveEnvScope(config?.public, source, "public")
+  };
+  return resolved;
+}
+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 setEnv(env2) {
+  currentEnv = prepareEnv(env2);
+  if (typeof window === "undefined") {
+    farmEnvGlobal[FARM_ENV_SYMBOL] = currentEnv;
+  }
+}
+function getResolvedEnv() {
+  const env2 = getCurrentEnv();
+  if (typeof window === "undefined") readRuntimeServerEnv(env2);
+  return env2;
+}
+function resolveEnvScope(shape, source, scope) {
+  if (!shape) {
+    return {};
+  }
+  const resolved = {};
+  for (const [key, parser] of Object.entries(shape)) {
+    try {
+      resolved[key] = parseEnvValue(parser, source[key], key, scope);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Invalid ${scope} env "${key}": ${message}`);
+    }
+  }
+  return resolved;
+}
+function parseEnvValue(parser, value, key, scope) {
+  if (typeof parser === "function") {
+    return parser(value, { key, scope });
+  }
+  if (parser && typeof parser.parse === "function") {
+    return parser.parse(value);
+  }
+  throw new Error("expected a parser function or schema with parse()");
+}
+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(resolveEnv, "resolveEnv");
+    __name(createBundledEnv, "createBundledEnv");
+    __name(setEnv, "setEnv");
+    __name(getResolvedEnv, "getResolvedEnv");
+    env = createEnvProxy("server");
+    publicEnv = createEnvProxy("public");
+    __name(resolveEnvScope, "resolveEnvScope");
+    __name(parseEnvValue, "parseEnvValue");
+    __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/plugin-dependencies.ts
 function pluginShortName(name2) {
   return name2.slice(Math.max(name2.lastIndexOf(":"), name2.lastIndexOf("/")) + 1);
@@ -5786,168 +6039,6 @@ var init_cron = __esm({
   }
 });
 
-// src/env.ts
-function resolveEnv(config, source = getProcessEnv()) {
-  const resolved = {
-    server: resolveEnvScope(config?.server, source, "server"),
-    public: resolveEnvScope(config?.public, source, "public")
-  };
-  return resolved;
-}
-function setEnv(env2) {
-  currentEnv = normalizeResolvedEnv(env2);
-  if (typeof window === "undefined") {
-    farmEnvGlobal[FARM_ENV_SYMBOL] = currentEnv;
-  }
-}
-function getResolvedEnv() {
-  return getCurrentEnv();
-}
-function resolveEnvScope(shape, source, scope) {
-  if (!shape) {
-    return {};
-  }
-  const resolved = {};
-  for (const [key, parser] of Object.entries(shape)) {
-    try {
-      resolved[key] = parseEnvValue(parser, source[key], key, scope);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      throw new Error(`Invalid ${scope} env "${key}": ${message}`);
-    }
-  }
-  return resolved;
-}
-function parseEnvValue(parser, value, key, scope) {
-  if (typeof parser === "function") {
-    return parser(value, { key, scope });
-  }
-  if (parser && typeof parser.parse === "function") {
-    return parser.parse(value);
-  }
-  throw new Error("expected a parser function or schema with parse()");
-}
-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: 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, 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();
-    __name(resolveEnv, "resolveEnv");
-    __name(setEnv, "setEnv");
-    __name(getResolvedEnv, "getResolvedEnv");
-    env = createEnvProxy("server");
-    publicEnv = createEnvProxy("public");
-    __name(resolveEnvScope, "resolveEnvScope");
-    __name(parseEnvValue, "parseEnvValue");
-    __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(isRecord, "isRecord");
-    __name(getProcessEnv, "getProcessEnv");
-  }
-});
-
 // src/app-markdown-config.ts
 function resolveMdxConfig(config) {
   return {
@@ -14322,9 +14413,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) {
@@ -14392,8 +14484,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) {
@@ -14518,6 +14610,161 @@ function isTypeOnlyNamedClause(tokens, startIndex, endIndex) {
   }
   return true;
 }
+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 };
+}
+function resolveProjectAliasSourcePath(specifier, root) {
+  if (!root) return void 0;
+  const projectRoot = import_path5.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_path5.default.normalize(match.alias.wildcard ? target.replace("*", match.captured) : target)
+    )
+  );
+}
+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);
+}
+function getProjectImportAliases(projectRoot) {
+  const stamp = PROJECT_ALIAS_FILES.map((file) => {
+    try {
+      return String(import_fs2.default.statSync(import_path5.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_path5.default.join(projectRoot, "src", "*")]
+    });
+  }
+  projectImportAliasCache.set(projectRoot, { stamp, aliases });
+  return aliases;
+}
+function readTsconfigPathAliases(projectRoot) {
+  for (const name2 of ["tsconfig.json", "jsconfig.json"]) {
+    const configPath = import_path5.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_path5.default.resolve(base, target))
+        }
+      ];
+    });
+  }
+  return [];
+}
+function readTsconfigPaths(configPath, visited) {
+  if (visited.has(configPath)) return null;
+  visited.add(configPath);
+  const config = readJsonWithComments(configPath);
+  if (!config) return null;
+  const directory = import_path5.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_path5.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_path5.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 };
+}
+function readPackageImportAliases(projectRoot) {
+  const imports = readPackageJson(import_path5.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_path5.default.resolve(projectRoot, target)]
+      }
+    ];
+  });
+}
+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;
+  }
+}
 function resolveImportedModuleSourcePath(importerPath, specifier, root) {
   if (!specifier.startsWith(".") && !specifier.startsWith("/")) {
     return resolvePackageModuleSourcePath(importerPath, specifier, root);
@@ -14648,7 +14895,7 @@ function resolveSourceCandidate(candidates) {
   }
   return null;
 }
-var import_fs2, import_path5, import_url3, FARM_ISOLATED_HYDRATION_MAX_BOUNDARIES, RESOLVABLE_SOURCE_EXTENSIONS, REGEXP_PREFIX_PUNCTUATION, REGEXP_PREFIX_KEYWORDS, PARSER_SENSITIVE_JSX_CONTAINERS;
+var import_fs2, import_path5, import_url3, FARM_ISOLATED_HYDRATION_MAX_BOUNDARIES, RESOLVABLE_SOURCE_EXTENSIONS, REGEXP_PREFIX_PUNCTUATION, REGEXP_PREFIX_KEYWORDS, PARSER_SENSITIVE_JSX_CONTAINERS, projectImportAliasCache, PROJECT_ALIAS_FILES;
 var init_client_component = __esm({
   "src/utils/client-component.ts"() {
     "use strict";
@@ -14754,6 +15001,16 @@ var init_client_component = __esm({
     __name(inspectPackageClientBoundary, "inspectPackageClientBoundary");
     __name(getImportSpecifiers, "getImportSpecifiers");
     __name(isTypeOnlyNamedClause, "isTypeOnlyNamedClause");
+    __name(resolveImportedModule, "resolveImportedModule");
+    projectImportAliasCache = /* @__PURE__ */ new Map();
+    PROJECT_ALIAS_FILES = ["tsconfig.json", "jsconfig.json", "package.json"];
+    __name(resolveProjectAliasSourcePath, "resolveProjectAliasSourcePath");
+    __name(matchProjectImportAlias, "matchProjectImportAlias");
+    __name(getProjectImportAliases, "getProjectImportAliases");
+    __name(readTsconfigPathAliases, "readTsconfigPathAliases");
+    __name(readTsconfigPaths, "readTsconfigPaths");
+    __name(readPackageImportAliases, "readPackageImportAliases");
+    __name(readJsonWithComments, "readJsonWithComments");
     __name(resolveImportedModuleSourcePath, "resolveImportedModuleSourcePath");
     __name(resolvePackageModuleSourcePath, "resolvePackageModuleSourcePath");
     __name(findPackageDirectory, "findPackageDirectory");
@@ -20221,7 +20478,7 @@ var init_server3 = __esm({
 var version;
 var init_package = __esm({
   "package.json"() {
-    version = "0.1.14";
+    version = "0.1.16";
   }
 });
 
@@ -36305,7 +36562,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;
 }
@@ -40700,6 +40957,7 @@ var fs15, path43, import_node_url12, ALL_TYPE_ARTIFACTS, createEmptyTypeArtifact
 var init_vite2 = __esm({
   "src/vite.ts"() {
     "use strict";
+    init_env();
     init_app();
     init_utils();
     init_plugin();
@@ -40915,7 +41173,7 @@ export const farmRegistry: {
   clientManifest?: any;
   routePaths?: Record<string, string>;
 } = {
-  env: ${JSON.stringify(config.env || { server: {}, public: {} }, null, 2)},
+  env: ${JSON.stringify(createBundledEnv(config.env), null, 2)},
   deploymentId: ${JSON.stringify(config.deploymentId)},
   basePath: ${JSON.stringify(config.basePath)},
   apiBasePath: ${JSON.stringify(apiBasePath)},
@@ -41419,7 +41677,7 @@ export default defineEventHandler(async (event: H3Event) => {
           farmRegistry.apiRouteManager = apiRouteManager;
           farmRegistry.routeManager = routeManager;
           farmRegistry.serverRenderer = serverRenderer;
-          farmRegistry.env = config.env || { server: {}, public: {} };
+          farmRegistry.env = createBundledEnv(config.env);
           farmRegistry.deploymentId = config.deploymentId;
           farmRegistry.basePath = config.basePath;
         };
@@ -41484,6 +41742,7 @@ var import_path16;
 var init_nitro = __esm({
   "src/nitro/index.ts"() {
     "use strict";
+    init_env();
     import_path16 = __toESM(require("path"));
     init_workflows();
     init_cron();
@@ -41506,6 +41765,7 @@ __export(build_runtime_exports, {
 module.exports = __toCommonJS(build_runtime_exports);
 
 // src/build/index.ts
+init_env();
 init_config4();
 var import_path17 = __toESM(require("path"));
 var import_node_fs14 = require("fs");
@@ -41516,6 +41776,7 @@ init_server_path();
 init_layers();
 
 // src/nitro/universal-build.ts
+init_env();
 init_config4();
 
 // src/nitro/client-css-href.ts
@@ -46200,7 +46461,7 @@ async function buildSSRInMemory(productionVite, config, root, routeManager, apiR
       },
       define: {
         __FARM_API_BASE_URL__: JSON.stringify(config.api.baseURL),
-        __FARM_ENV__: JSON.stringify(config.env || { server: {}, public: {} }),
+        __FARM_ENV__: JSON.stringify(createBundledEnv(config.env)),
         __FARM_PUBLIC_ENV__: JSON.stringify(config.env?.public || {})
       },
       plugins: [
@@ -51651,7 +51912,7 @@ async function buildSSR(viteBuild, config, root, srcDir, outputDir) {
     },
     define: {
       __FARM_API_BASE_URL__: JSON.stringify(config.api.baseURL),
-      __FARM_ENV__: JSON.stringify(config.env || { server: {}, public: {} }),
+      __FARM_ENV__: JSON.stringify(createBundledEnv(config.env)),
       __FARM_PUBLIC_ENV__: JSON.stringify(config.env?.public || {})
     },
     plugins: [
@@ -51734,7 +51995,7 @@ async function buildNitro(config, routeManager, apiRouteManager, serverRenderer,
     farmRegistry.apiRouteManager = apiRouteManager;
     farmRegistry.routeManager = routeManager;
     farmRegistry.serverRenderer = serverRenderer;
-    farmRegistry.env = config.env || { server: {}, public: {} };
+    farmRegistry.env = createBundledEnv(config.env);
     const routePaths = {};
     for (const [pattern, entry] of routeManager.getRoutes()) {
       const bundledPath = entry.modulePath.replace(/.*\/src\/app\//, "").replace(/\.(tsx?|jsx?)$/, ".js");