@farm.js/core 0.1.15 → 0.1.17

package/dist/api.mjs

@@ -1,6 +1,6 @@
 import {
   farmApiPlugin
-} from "./chunk-LK6FGAQR.mjs";
+} from "./chunk-UDBJCUPA.mjs";
 import {
   APIClientError,
   FARM_API_ROUTE_META_SYMBOL,
@@ -13,17 +13,17 @@ import {
   isAPIRouteRef,
   resolveServerFnInvalidateTargets,
   settleServerFnOptimisticUpdates
-} from "./chunk-KUO3GBPK.mjs";
+} from "./chunk-L6V3P73N.mjs";
 import "./chunk-72AK62H5.mjs";
-import "./chunk-HKLRP3BN.mjs";
+import "./chunk-5SPPCN5J.mjs";
 import "./chunk-QVYLBY73.mjs";
 import "./chunk-R3DS7A2T.mjs";
 import "./chunk-IOEH4VWN.mjs";
 import {
   APIRouteConflictError,
   APIRouteManager
-} from "./chunk-ZHOIQC6U.mjs";
-import "./chunk-VO5SCWF5.mjs";
+} from "./chunk-ATERBVHQ.mjs";
+import "./chunk-BNGS6KJ6.mjs";
 import "./chunk-CU625VAY.mjs";
 import "./chunk-JNGIWIY6.mjs";
 import "./chunk-FV45CKBC.mjs";
@@ -34,7 +34,7 @@ import {
   isWebResponse,
   normalizeRouteResponse,
   resolveAPIRouteEndpoint
-} from "./chunk-DPZUDPVJ.mjs";
+} from "./chunk-XP777LRD.mjs";
 import {
   resolveFarmAPIServerBasePath
 } from "./chunk-I6XDAKWQ.mjs";
@@ -52,7 +52,7 @@ import {
   createRouteFactory,
   isEndpointFailure,
   resolvePluginRoutes
-} from "./chunk-OWTIOHON.mjs";
+} from "./chunk-SYGGPS4A.mjs";
 import "./chunk-W3B4PKAW.mjs";
 import "./chunk-5WI2S4CO.mjs";
 import "./chunk-EA5K5BKU.mjs";
@@ -86,7 +86,7 @@ import {
   resolveFarmAPIRequestURL
 } from "./chunk-7LTCDQRS.mjs";
 import "./chunk-IXUY2F5U.mjs";
-import "./chunk-IGO2HEV7.mjs";
+import "./chunk-F6SJAKFJ.mjs";
 import "./chunk-4SIYUGRY.mjs";
 import "./chunk-C4NCTZLM.mjs";
 import "./chunk-FUZEBRP3.mjs";

package/dist/{app-wIYse61b.d.ts → app-BHY_10Lm.d.ts}

@@ -1,4 +1,4 @@
-import { w as FarmConfig, P as ParsedRoute, ao as ResolvedFarmRouteRuntimeConfig, ap as ApplicationMetadataRouteKind, k as RouteModule, a0 as LayoutModule, a5 as SSGCollectionResult, b as FarmRequest, c as FarmResponse, aq as ResolvedFarmAPIConfig, m as FarmMdxResolvedConfig, ar as ResolvedFarmDevtoolsConfig, as as ResolvedFarmDevIndicatorsConfig, at as ResolvedFarmAuthConfig, au as ResolvedFarmPerformanceConfig, av as ResolvedFarmSecurityConfig } from './client-plugins-CslwYp3E.js';
+import { w as FarmConfig, P as ParsedRoute, ao as ResolvedFarmRouteRuntimeConfig, ap as ApplicationMetadataRouteKind, k as RouteModule, a0 as LayoutModule, a5 as SSGCollectionResult, b as FarmRequest, c as FarmResponse, aq as ResolvedFarmAPIConfig, m as FarmMdxResolvedConfig, ar as ResolvedFarmDevtoolsConfig, as as ResolvedFarmDevIndicatorsConfig, at as ResolvedFarmAuthConfig, au as ResolvedFarmPerformanceConfig, av as ResolvedFarmSecurityConfig } from './client-plugins-C089bQhN.js';
 import { F as FarmDocsResolvedConfig } from './types-D-1WTE72.js';
 import { FarmMarkdownResolvedConfig } from './markdown.js';
 import { F as FarmWorkflowsResolvedConfig } from './workflows-CR9ex-gz.js';
@@ -7,9 +7,9 @@ import { R as ResolvedFarmImageConfig } from './image-config-Duob7wER.js';
 import { ProgrammaticRedirectRoute, ProgrammaticRouteSearchClientOptions } from './routes.js';
 import { ViteDevServer } from 'vite';
 import { F as FarmIslandStrategy } from './island-CfGru1MO.js';
-import { M as MetadataImageKind } from './metadata-BsUcOEXg.js';
+import { M as MetadataImageKind } from './metadata-BcNJP4fq.js';
 import { FarmServerRendererRuntime, FarmRenderer } from './renderer.js';
-import { F as FarmRouteRenderPlan } from './render-plan-EG4hNFjy.js';
+import { F as FarmRouteRenderPlan } from './render-plan-DOB9cV-h.js';
 import { R as ResolvedFarmI18nConfig } from './types-Z0aotQ8w.js';
 import { F as FarmI18nRuntime } from './runtime-BirxPwbZ.js';
 import { R as ResolvedFarmThemeConfig } from './types-DQnyD3VD.js';

package/dist/{app-B3nVSjen.d.mts → app-BMk0do23.d.mts}

@@ -1,4 +1,4 @@
-import { w as FarmConfig, P as ParsedRoute, ao as ResolvedFarmRouteRuntimeConfig, ap as ApplicationMetadataRouteKind, k as RouteModule, a0 as LayoutModule, a5 as SSGCollectionResult, b as FarmRequest, c as FarmResponse, aq as ResolvedFarmAPIConfig, m as FarmMdxResolvedConfig, ar as ResolvedFarmDevtoolsConfig, as as ResolvedFarmDevIndicatorsConfig, at as ResolvedFarmAuthConfig, au as ResolvedFarmPerformanceConfig, av as ResolvedFarmSecurityConfig } from './client-plugins-C1EgdoJM.mjs';
+import { w as FarmConfig, P as ParsedRoute, ao as ResolvedFarmRouteRuntimeConfig, ap as ApplicationMetadataRouteKind, k as RouteModule, a0 as LayoutModule, a5 as SSGCollectionResult, b as FarmRequest, c as FarmResponse, aq as ResolvedFarmAPIConfig, m as FarmMdxResolvedConfig, ar as ResolvedFarmDevtoolsConfig, as as ResolvedFarmDevIndicatorsConfig, at as ResolvedFarmAuthConfig, au as ResolvedFarmPerformanceConfig, av as ResolvedFarmSecurityConfig } from './client-plugins-JXXmZliS.mjs';
 import { F as FarmDocsResolvedConfig } from './types-D-1WTE72.mjs';
 import { FarmMarkdownResolvedConfig } from './markdown.mjs';
 import { F as FarmWorkflowsResolvedConfig } from './workflows-CR9ex-gz.mjs';
@@ -7,9 +7,9 @@ import { R as ResolvedFarmImageConfig } from './image-config-Duob7wER.mjs';
 import { ProgrammaticRedirectRoute, ProgrammaticRouteSearchClientOptions } from './routes.mjs';
 import { ViteDevServer } from 'vite';
 import { F as FarmIslandStrategy } from './island-CfGru1MO.mjs';
-import { M as MetadataImageKind } from './metadata-B1bxCPUY.mjs';
+import { M as MetadataImageKind } from './metadata-C1Z9vLbb.mjs';
 import { FarmServerRendererRuntime, FarmRenderer } from './renderer.mjs';
-import { F as FarmRouteRenderPlan } from './render-plan-CNUlzylR.mjs';
+import { F as FarmRouteRenderPlan } from './render-plan-BLIfc4jt.mjs';
 import { R as ResolvedFarmI18nConfig } from './types-Z0aotQ8w.mjs';
 import { F as FarmI18nRuntime } from './runtime-AOJge4vQ.mjs';
 import { R as ResolvedFarmThemeConfig } from './types-DQnyD3VD.mjs';

package/dist/app-markdown.d.mts

@@ -1,9 +1,10 @@
-import { l as FarmMdxComponents, m as FarmMdxResolvedConfig, k as RouteModule } from './client-plugins-C1EgdoJM.mjs';
-export { o as FarmMdxComponent, p as FarmMdxUserConfig, r as resolveFarmMdxComponentsModulePath, n as resolveMdxConfig } from './client-plugins-C1EgdoJM.mjs';
+import { l as FarmMdxComponents, m as FarmMdxResolvedConfig, k as RouteModule } from './client-plugins-JXXmZliS.mjs';
+export { o as FarmMdxComponent, p as FarmMdxUserConfig, r as resolveFarmMdxComponentsModulePath, n as resolveMdxConfig } from './client-plugins-JXXmZliS.mjs';
 export { FarmMarkdownPageModuleInput, FarmMarkdownPageSource, createFarmMarkdownRouteModule, createFarmMarkdownSourceResponse, createMarkdownMetadata, isFarmMarkdownPageFile, normalizeFarmMarkdownRoutePath, parseMarkdownFrontmatter, titleFromMarkdown } from './internal/app-markdown-runtime.mjs';
 export { FARM_MARKDOWN_CONTENT_TYPE, createFarmMarkdownErrorBody, farmRequestWantsMarkdown } from './markdown.mjs';
 import './lifecycle-DK06VuKP.mjs';
-import './route-C6UClI1z.mjs';
+import './route-B0XrsrFk.mjs';
+import './endpoint-DAc96i93.mjs';
 import './cache.mjs';
 import './renderer.mjs';
 import './deployment.mjs';
@@ -29,6 +30,8 @@ import './server-fn-error-DDh14a0V.mjs';
 import 'esbuild';
 import './image-config-Duob7wER.mjs';
 import './types-Z0aotQ8w.mjs';
+import './server-fn.mjs';
+import './server-query.mjs';
 import './types-DQnyD3VD.mjs';
 import './font.mjs';
 import './after.mjs';

package/dist/app-markdown.d.ts

@@ -1,9 +1,10 @@
-import { l as FarmMdxComponents, m as FarmMdxResolvedConfig, k as RouteModule } from './client-plugins-CslwYp3E.js';
-export { o as FarmMdxComponent, p as FarmMdxUserConfig, r as resolveFarmMdxComponentsModulePath, n as resolveMdxConfig } from './client-plugins-CslwYp3E.js';
+import { l as FarmMdxComponents, m as FarmMdxResolvedConfig, k as RouteModule } from './client-plugins-C089bQhN.js';
+export { o as FarmMdxComponent, p as FarmMdxUserConfig, r as resolveFarmMdxComponentsModulePath, n as resolveMdxConfig } from './client-plugins-C089bQhN.js';
 export { FarmMarkdownPageModuleInput, FarmMarkdownPageSource, createFarmMarkdownRouteModule, createFarmMarkdownSourceResponse, createMarkdownMetadata, isFarmMarkdownPageFile, normalizeFarmMarkdownRoutePath, parseMarkdownFrontmatter, titleFromMarkdown } from './internal/app-markdown-runtime.js';
 export { FARM_MARKDOWN_CONTENT_TYPE, createFarmMarkdownErrorBody, farmRequestWantsMarkdown } from './markdown.js';
 import './lifecycle-DK06VuKP.js';
-import './route-CHBaW55F.js';
+import './route-DOEpbyWZ.js';
+import './endpoint-1zA994xL.js';
 import './cache.js';
 import './renderer.js';
 import './deployment.js';
@@ -29,6 +30,8 @@ import './server-fn-error-DDh14a0V.js';
 import 'esbuild';
 import './image-config-Duob7wER.js';
 import './types-Z0aotQ8w.js';
+import './server-fn.js';
+import './server-query.js';
 import './types-DQnyD3VD.js';
 import './font.js';
 import './after.js';

package/dist/app-markdown.mjs

@@ -1,7 +1,7 @@
 import {
   createFarmMarkdownRouteModuleFromFile,
   loadFarmMdxComponents
-} from "./chunk-KATQ6I56.mjs";
+} from "./chunk-XWAYMDLB.mjs";
 import {
   createFarmMarkdownRouteModule,
   createFarmMarkdownSourceResponse,
@@ -10,7 +10,7 @@ import {
   normalizeFarmMarkdownRoutePath,
   parseMarkdownFrontmatter,
   titleFromMarkdown
-} from "./chunk-LUC2FAGW.mjs";
+} from "./chunk-6VQIKZZO.mjs";
 import {
   resolveFarmMdxComponentsModulePath,
   resolveMdxConfig
@@ -19,7 +19,7 @@ import {
   FARM_MARKDOWN_CONTENT_TYPE,
   createFarmMarkdownErrorBody,
   farmRequestWantsMarkdown
-} from "./chunk-6SCB2MXB.mjs";
+} from "./chunk-SXHV42UQ.mjs";
 import "./chunk-LPEX4YW6.mjs";
 export {
   FARM_MARKDOWN_CONTENT_TYPE,

package/dist/cache.cjs

@@ -658,6 +658,8 @@ var _FarmDataCache = class _FarmDataCache {
   constructor(config = {}) {
     this.entries = /* @__PURE__ */ new Map();
     this.inflight = /* @__PURE__ */ new Map();
+    /** Local entries by tag, so tag counts and pruning never scan unrelated entries. */
+    this.entriesByTag = /* @__PURE__ */ new Map();
     this.invalidatedTagVersions = /* @__PURE__ */ new Map();
     this.activeGenerations = /* @__PURE__ */ new Set();
     this.version = 0;
@@ -676,6 +678,7 @@ var _FarmDataCache = class _FarmDataCache {
   configure(config = {}) {
     this.generation++;
     this.entries.clear();
+    this.entriesByTag.clear();
     this.inflight.clear();
     this.invalidatedTagVersions.clear();
     this.activeGenerations.clear();
@@ -842,14 +845,12 @@ var _FarmDataCache = class _FarmDataCache {
     return entry;
   }
   delete(key) {
-    const deleted = this.entries.delete(key);
-    if (deleted) this.pruneInvalidatedTagVersions();
+    const deleted = this.deleteLocalEntry(key);
     emitFarmEvent({ type: "cache.delete", key, deleted });
     return deleted;
   }
   async deleteAsync(key) {
-    const deleted = this.entries.delete(key);
-    if (deleted) this.pruneInvalidatedTagVersions();
+    const deleted = this.deleteLocalEntry(key);
     if (this.adapter) {
       await this.adapter.delete(this.createAdapterKey(key));
     }
@@ -860,6 +861,7 @@ var _FarmDataCache = class _FarmDataCache {
     const count = this.entries.size;
     this.generation++;
     this.entries.clear();
+    this.entriesByTag.clear();
     this.inflight.clear();
     this.invalidatedTagVersions.clear();
     this.activeGenerations.clear();
@@ -945,23 +947,32 @@ var _FarmDataCache = class _FarmDataCache {
       return cached.value;
     }
     const inflight = this.inflight.get(key);
-    if (inflight) {
+    if (inflight && !this.wasInvalidatedSince(inflight.tags, inflight.startVersion)) {
       emitFarmEvent({ type: "cache.dedupe", key });
-      return inflight;
+      return inflight.promise;
     }
     const tags = Array.from(normalizeCacheOptionsTags(options));
     const generation = this.generation;
+    const startVersion = this.version;
     const promise = this.fillCacheEntry(key, producer, options, tags, generation).catch((error) => {
       emitFarmEvent({ type: "cache.error", key, operation: "set", error });
       throw error;
     }).finally(() => {
-      if (this.inflight.get(key) === promise) {
+      if (this.inflight.get(key)?.promise === promise) {
         this.inflight.delete(key);
       }
     });
-    this.inflight.set(key, promise);
+    this.inflight.set(key, { promise, tags, startVersion });
     return promise;
   }
+  /** A fill that started before one of its tags was invalidated cannot satisfy later readers. */
+  wasInvalidatedSince(tags, version) {
+    for (const tag of tags) {
+      const invalidatedVersion = this.invalidatedTagVersions.get(tag);
+      if (invalidatedVersion !== void 0 && invalidatedVersion > version) return true;
+    }
+    return false;
+  }
   async fillCacheEntry(key, producer, options, tags, generation) {
     const adapter = this.adapter;
     const namespace = this.namespace;
@@ -1002,7 +1013,7 @@ var _FarmDataCache = class _FarmDataCache {
       return value;
     } finally {
       this.activeGenerations.delete(activeGeneration);
-      this.pruneInvalidatedTagVersions();
+      this.pruneInvalidatedTagVersions(activeGeneration.tags);
       if (leaseToken && adapter?.releaseLease) {
         try {
           await adapter.releaseLease(leaseKey, leaseToken);
@@ -1047,18 +1058,9 @@ var _FarmDataCache = class _FarmDataCache {
     }
     return void 0;
   }
-  countEntriesForTag(tag) {
-    let count = 0;
-    for (const entry of this.entries.values()) {
-      if (entry.tags.has(tag)) {
-        count++;
-      }
-    }
-    return count;
-  }
   countEntriesForTags(tags) {
     let count = 0;
-    for (const entry of this.entries.values()) {
+    for (const entry of this.entriesByTag.get(tags[0]) ?? []) {
       if (tags.every((tag) => entry.tags.has(tag))) {
         count++;
       }
@@ -1066,10 +1068,10 @@ var _FarmDataCache = class _FarmDataCache {
     return count;
   }
   invalidateTag(normalizedTag) {
-    const count = this.countEntriesForTag(normalizedTag);
+    const count = this.entriesByTag.get(normalizedTag)?.size ?? 0;
     this.invalidatedTagVersions.delete(normalizedTag);
     this.invalidatedTagVersions.set(normalizedTag, ++this.version);
-    this.pruneInvalidatedTagVersions();
+    this.pruneInvalidatedTagVersions([normalizedTag]);
     return count;
   }
   toPublicEntry(entry) {
@@ -1099,19 +1101,51 @@ var _FarmDataCache = class _FarmDataCache {
     this.entries.set(key, entry);
   }
   storeLocalEntry(entry) {
-    this.entries.delete(entry.key);
+    const removed = [];
+    const replaced = this.detachLocalEntry(entry.key);
+    if (replaced) removed.push(replaced);
     this.entries.set(entry.key, entry);
+    for (const tag of entry.tags) {
+      let tagged = this.entriesByTag.get(tag);
+      if (!tagged) this.entriesByTag.set(tag, tagged = /* @__PURE__ */ new Set());
+      tagged.add(entry);
+    }
     while (this.entries.size > this.maxEntries) {
       const oldestKey = this.entries.keys().next().value;
       if (oldestKey === void 0) break;
-      this.entries.delete(oldestKey);
+      removed.push(this.detachLocalEntry(oldestKey));
     }
-    this.pruneInvalidatedTagVersions();
+    for (const removedEntry of removed) this.pruneInvalidatedTagVersions(removedEntry.tags);
+  }
+  deleteLocalEntry(key) {
+    const entry = this.detachLocalEntry(key);
+    if (!entry) return false;
+    this.pruneInvalidatedTagVersions(entry.tags);
+    return true;
+  }
+  detachLocalEntry(key) {
+    const entry = this.entries.get(key);
+    if (!entry) return void 0;
+    this.entries.delete(key);
+    for (const tag of entry.tags) {
+      const tagged = this.entriesByTag.get(tag);
+      if (!tagged) continue;
+      tagged.delete(entry);
+      if (tagged.size === 0) this.entriesByTag.delete(tag);
+    }
+    return entry;
   }
-  pruneInvalidatedTagVersions() {
-    tags: for (const [tag, invalidatedVersion] of this.invalidatedTagVersions) {
-      for (const entry of this.entries.values()) {
-        if (entry.tags.has(tag) && entry.createdVersion < invalidatedVersion) continue tags;
+  /**
+   * Drop invalidation versions that no local entry or active fill can be stale against.
+   * Callers pass only the tags whose dependents just changed, so the cost is bounded by
+   * the entries sharing those tags rather than by the whole cache.
+   */
+  pruneInvalidatedTagVersions(tags) {
+    tags: for (const tag of tags) {
+      const invalidatedVersion = this.invalidatedTagVersions.get(tag);
+      if (invalidatedVersion === void 0) continue;
+      for (const entry of this.entriesByTag.get(tag) ?? []) {
+        if (entry.createdVersion < invalidatedVersion) continue tags;
       }
       for (const generation of this.activeGenerations) {
         if (generation.tags.has(tag) && generation.createdVersion < invalidatedVersion)

package/dist/cache.d.mts

@@ -160,6 +160,8 @@ interface FarmCacheStaleEntry {
 declare class FarmDataCache {
     private entries;
     private inflight;
+    /** Local entries by tag, so tag counts and pruning never scan unrelated entries. */
+    private entriesByTag;
     private invalidatedTagVersions;
     private activeGenerations;
     private version;
@@ -197,15 +199,23 @@ declare class FarmDataCache {
     revalidatePath(routePath: string): number;
     revalidatePathAsync(routePath: string): Promise<number>;
     getOrSet<T>(key: string, producer: () => Promise<T> | T, options?: FarmCacheOptions): Promise<T>;
+    /** A fill that started before one of its tags was invalidated cannot satisfy later readers. */
+    private wasInvalidatedSince;
     private fillCacheEntry;
     private waitForAdapterEntry;
-    private countEntriesForTag;
     private countEntriesForTags;
     private invalidateTag;
     private toPublicEntry;
     private hydrateLocalEntry;
     private touchEntry;
     private storeLocalEntry;
+    private deleteLocalEntry;
+    private detachLocalEntry;
+    /**
+     * Drop invalidation versions that no local entry or active fill can be stale against.
+     * Callers pass only the tags whose dependents just changed, so the cost is bounded by
+     * the entries sharing those tags rather than by the whole cache.
+     */
     private pruneInvalidatedTagVersions;
     private createAdapterKey;
     private createAdapterTag;

package/dist/cache.d.ts

@@ -160,6 +160,8 @@ interface FarmCacheStaleEntry {
 declare class FarmDataCache {
     private entries;
     private inflight;
+    /** Local entries by tag, so tag counts and pruning never scan unrelated entries. */
+    private entriesByTag;
     private invalidatedTagVersions;
     private activeGenerations;
     private version;
@@ -197,15 +199,23 @@ declare class FarmDataCache {
     revalidatePath(routePath: string): number;
     revalidatePathAsync(routePath: string): Promise<number>;
     getOrSet<T>(key: string, producer: () => Promise<T> | T, options?: FarmCacheOptions): Promise<T>;
+    /** A fill that started before one of its tags was invalidated cannot satisfy later readers. */
+    private wasInvalidatedSince;
     private fillCacheEntry;
     private waitForAdapterEntry;
-    private countEntriesForTag;
     private countEntriesForTags;
     private invalidateTag;
     private toPublicEntry;
     private hydrateLocalEntry;
     private touchEntry;
     private storeLocalEntry;
+    private deleteLocalEntry;
+    private detachLocalEntry;
+    /**
+     * Drop invalidation versions that no local entry or active fill can be stale against.
+     * Callers pass only the tags whose dependents just changed, so the cost is bounded by
+     * the entries sharing those tags rather than by the whole cache.
+     */
     private pruneInvalidatedTagVersions;
     private createAdapterKey;
     private createAdapterTag;

package/dist/cache.mjs

@@ -17,7 +17,7 @@ import {
   storageCacheAdapter,
   unstable_cache,
   updateTag
-} from "./chunk-IGO2HEV7.mjs";
+} from "./chunk-F6SJAKFJ.mjs";
 import {
   applyFarmCacheInvalidations
 } from "./chunk-4SIYUGRY.mjs";

package/dist/{chunk-FOGLGRDS.mjs → chunk-4OOBRCJX.mjs}

@@ -1,9 +1,13 @@
+import {
+  readFarmEnvironmentValue
+} from "./chunk-ONUEYC6N.mjs";
 import {
   __name
 } from "./chunk-LPEX4YW6.mjs";
 
 // src/env.ts
 var FARM_ENV_SYMBOL = /* @__PURE__ */ Symbol.for("farm.env");
+var FARM_ENV_RUNTIME_SYMBOL = /* @__PURE__ */ Symbol.for("farm.env.runtime");
 var farmEnvGlobal = globalThis;
 var currentEnv = getInitialEnv();
 function resolveEnv(config, source = getProcessEnv()) {
@@ -14,23 +18,45 @@ function resolveEnv(config, source = getProcessEnv()) {
   return resolved;
 }
 __name(resolveEnv, "resolveEnv");
+function createBundledEnv(env2, source = getProcessEnv()) {
+  const resolved = normalizeResolvedEnv(env2 ?? {});
+  const server = {};
+  const runtime = {};
+  for (const [key, value] of Object.entries(resolved.server)) {
+    const raw = source[key];
+    const type = getRuntimeEnvType(value);
+    if (raw !== void 0 && isSameEnvValue(coerceRuntimeEnvValue(raw, type), value)) {
+      runtime[key] = type;
+    } else {
+      server[key] = value;
+    }
+  }
+  return {
+    server,
+    public: resolved.public,
+    ...Object.keys(runtime).length > 0 ? { runtime: { server: runtime } } : {}
+  };
+}
+__name(createBundledEnv, "createBundledEnv");
 function setEnv(env2) {
-  currentEnv = normalizeResolvedEnv(env2);
+  currentEnv = prepareEnv(env2);
   if (typeof window === "undefined") {
     farmEnvGlobal[FARM_ENV_SYMBOL] = currentEnv;
   }
 }
 __name(setEnv, "setEnv");
 function getResolvedEnv() {
-  return getCurrentEnv();
+  const env2 = getCurrentEnv();
+  if (typeof window === "undefined") readRuntimeServerEnv(env2);
+  return env2;
 }
 __name(getResolvedEnv, "getResolvedEnv");
 function getEnv(key) {
-  assertServerEnvAccess();
+  const server = getEnvScope("server");
   if (key === void 0) {
-    return getCurrentEnv().server;
+    return server;
   }
-  return getCurrentEnv().server[key];
+  return readServerEnvKey(server, key);
 }
 __name(getEnv, "getEnv");
 function getPublicEnv(key) {
@@ -78,7 +104,7 @@ function createEnvProxy(scope) {
           return void 0;
         }
         const env2 = getEnvScope(scope);
-        return env2[property];
+        return scope === "server" ? readServerEnvKey(env2, property) : env2[property];
       },
       ownKeys() {
         return Reflect.ownKeys(getEnvScope(scope));
@@ -102,12 +128,99 @@ function createEnvProxy(scope) {
 }
 __name(createEnvProxy, "createEnvProxy");
 function getEnvScope(scope) {
+  const env2 = getCurrentEnv();
   if (scope === "server") {
     assertServerEnvAccess();
+    readRuntimeServerEnv(env2);
   }
-  return getCurrentEnv()[scope] || {};
+  return env2[scope] || {};
 }
 __name(getEnvScope, "getEnvScope");
+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;
+}
+__name(readServerEnvKey, "readServerEnvKey");
+function readRuntimeServerEnv(env2) {
+  const state = env2[FARM_ENV_RUNTIME_SYMBOL];
+  if (!state) return;
+  for (const [key, type] of Object.entries(state.pending)) {
+    const raw = readFarmEnvironmentValue(key);
+    if (raw === void 0) continue;
+    env2.server[key] = coerceRuntimeEnvValue(raw, type);
+    delete state.pending[key];
+  }
+}
+__name(readRuntimeServerEnv, "readRuntimeServerEnv");
+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";
+}
+__name(getRuntimeEnvType, "getRuntimeEnvType");
+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;
+}
+__name(coerceRuntimeEnvValue, "coerceRuntimeEnvValue");
+function isSameEnvValue(left, right) {
+  if (Object.is(left, right)) return true;
+  if (Array.isArray(left) || Array.isArray(right)) {
+    return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((item, index) => isSameEnvValue(item, right[index]));
+  }
+  if (!isPlainObject(left) || !isPlainObject(right)) return false;
+  const keys = Object.keys(left);
+  return keys.length === Object.keys(right).length && keys.every(
+    (key) => Object.prototype.hasOwnProperty.call(right, key) && isSameEnvValue(left[key], right[key])
+  );
+}
+__name(isSameEnvValue, "isSameEnvValue");
+function isPlainObject(value) {
+  if (!value || typeof value !== "object") return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+__name(isPlainObject, "isPlainObject");
+function prepareEnv(env2) {
+  const normalized = normalizeResolvedEnv(env2);
+  const runtime = env2.runtime?.server;
+  if (!isRecord(runtime) || Object.keys(runtime).length === 0) return normalized;
+  const prepared = { server: { ...normalized.server }, public: normalized.public };
+  Object.defineProperty(prepared, FARM_ENV_RUNTIME_SYMBOL, {
+    value: {
+      pending: { ...runtime },
+      warned: /* @__PURE__ */ new Set()
+    },
+    enumerable: false
+  });
+  return prepared;
+}
+__name(prepareEnv, "prepareEnv");
 function assertServerEnvAccess() {
   if (typeof window !== "undefined") {
     throw new Error("Farm server env is not available in the browser. Use publicEnv.");
@@ -138,7 +251,7 @@ __name(getCurrentEnv, "getCurrentEnv");
 function getInjectedEnv() {
   try {
     if (typeof __FARM_ENV__ !== "undefined" && __FARM_ENV__) {
-      return normalizeResolvedEnv(__FARM_ENV__);
+      return prepareEnv(__FARM_ENV__);
     }
   } catch {
   }
@@ -176,6 +289,7 @@ __name(getProcessEnv, "getProcessEnv");
 
 export {
   resolveEnv,
+  createBundledEnv,
   setEnv,
   getResolvedEnv,
   getEnv,