@vercel/flags-core 1.8.1 → 1.9.0-0fd2f41-20260915094243

package/dist/{chunk-CKL562EU.cjs → chunk-ZUO5MVUD.cjs}

@@ -558,7 +558,7 @@ function bulkEvaluate(flags, shared) {
 }
 
 // package.json
-var version = "1.8.1";
+var version = "1.9.0-0fd2f41-20260915094243";
 
 // src/lib/report-value.ts
 function internalReportValue(key, value, data) {
@@ -956,6 +956,12 @@ function createCreateRawClient(fns) {
   };
 }
 
+// src/utils/debug.ts
+function debugLog(source, message, details = {}) {
+  if (!_optionalChain([process, 'access', _31 => _31.env, 'access', _32 => _32.DEBUG, 'optionalAccess', _33 => _33.includes, 'call', _34 => _34("@vercel/flags-core")])) return;
+  console.log(`@vercel/flags-core [${source}] ${message}`, details);
+}
+
 // src/utils/read-bundled-definitions.ts
 var sdkKeyHashCache = /* @__PURE__ */ new Map();
 async function computeHash(sdkKey) {
@@ -1035,8 +1041,8 @@ var MAX_RETRIES = 3;
 var MAX_EVENTS_PER_REQUEST = 2e3;
 var EVALUATING_OIDC_TOKEN_HEADER = "X-Vercel-Flags-OIDC-Token";
 var FLUSH_REASON_HEADER = "X-Vercel-Flags-Flush-Reason";
-var isDebugMode = _optionalChain([process, 'access', _31 => _31.env, 'access', _32 => _32.DEBUG, 'optionalAccess', _33 => _33.includes, 'call', _34 => _34("@vercel/flags-core")]);
-var debugLog = (...args) => {
+var isDebugMode = _optionalChain([process, 'access', _35 => _35.env, 'access', _36 => _36.DEBUG, 'optionalAccess', _37 => _37.includes, 'call', _38 => _38("@vercel/flags-core")]);
+var debugLog2 = (...args) => {
   if (!isDebugMode) return;
   console.log(...args);
 };
@@ -1082,7 +1088,7 @@ async function sendIngestChunk(options, eventsToSend, flushId, flushReason) {
         headers: await getIngestHeaders(options, flushReason),
         body: JSON.stringify(eventsToSend)
       });
-      debugLog(
+      debugLog2(
         `@vercel/flags-core: Ingest response ${response.status} for ${eventsToSend.length} events on ${response.headers.get("x-vercel-id")}`
       );
       if (response.ok) {
@@ -1114,7 +1120,7 @@ var SYMBOL_FOR_REQ_CONTEXT = /* @__PURE__ */ Symbol.for("@vercel/request-context
 var fromSymbol = globalThis;
 function getRequestContext() {
   try {
-    const ctx = _optionalChain([fromSymbol, 'access', _35 => _35[SYMBOL_FOR_REQ_CONTEXT], 'optionalAccess', _36 => _36.get, 'optionalCall', _37 => _37()]);
+    const ctx = _optionalChain([fromSymbol, 'access', _39 => _39[SYMBOL_FOR_REQ_CONTEXT], 'optionalAccess', _40 => _40.get, 'optionalCall', _41 => _41()]);
     if (ctx && Object.hasOwn(ctx, "headers")) {
       return {
         ctx,
@@ -1179,7 +1185,7 @@ var Scheduler = (_class = class {
   }
   resolveScheduledFlush(reason) {
     this.clearTimeouts();
-    _optionalChain([this, 'access', _38 => _38.resolveWait, 'optionalCall', _39 => _39(reason)]);
+    _optionalChain([this, 'access', _42 => _42.resolveWait, 'optionalCall', _43 => _43(reason)]);
   }
   reset() {
     this.pending = null;
@@ -1427,7 +1433,7 @@ var BundledSource = class {
    */
   async tryLoad() {
     const result = await this.getResult();
-    if (_optionalChain([result, 'optionalAccess', _40 => _40.state]) === "ok" && result.definitions) {
+    if (_optionalChain([result, 'optionalAccess', _44 => _44.state]) === "ok" && result.definitions) {
       return result.definitions;
     }
     return void 0;
@@ -1467,18 +1473,190 @@ async function fetchDatafile(options) {
       signal: controller.signal
     });
     clearTimeout(timeoutId);
-    _optionalChain([options, 'access', _41 => _41.signal, 'optionalAccess', _42 => _42.removeEventListener, 'call', _43 => _43("abort", onExternalAbort)]);
+    _optionalChain([options, 'access', _45 => _45.signal, 'optionalAccess', _46 => _46.removeEventListener, 'call', _47 => _47("abort", onExternalAbort)]);
     if (!res.ok) {
       throw new Error(`Failed to fetch data: ${res.statusText}`);
     }
     return res.json();
   } catch (error) {
     clearTimeout(timeoutId);
-    _optionalChain([options, 'access', _44 => _44.signal, 'optionalAccess', _45 => _45.removeEventListener, 'call', _46 => _46("abort", onExternalAbort)]);
+    _optionalChain([options, 'access', _48 => _48.signal, 'optionalAccess', _49 => _49.removeEventListener, 'call', _50 => _50("abort", onExternalAbort)]);
     throw error instanceof Error ? error : new Error("Unknown fetch error");
   }
 }
 
+// src/controller/header-source.ts
+
+
+// src/controller/tagged-data.ts
+function tagData(data, origin) {
+  return Object.assign(data, { _origin: origin });
+}
+function originToMetricsSource(origin) {
+  switch (origin) {
+    case "stream":
+    case "poll":
+    case "provided":
+      return "in-memory";
+    case "fetched":
+      return "remote";
+    case "bundled":
+      return "embedded";
+  }
+}
+
+// src/controller/typed-emitter.ts
+var TypedEmitter = (_class5 = class {constructor() { _class5.prototype.__init11.call(this); }
+  __init11() {this.handlers = /* @__PURE__ */ new Map()}
+  on(event, handler) {
+    let set = this.handlers.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.handlers.set(event, set);
+    }
+    set.add(handler);
+  }
+  off(event, handler) {
+    _optionalChain([this, 'access', _51 => _51.handlers, 'access', _52 => _52.get, 'call', _53 => _53(event), 'optionalAccess', _54 => _54.delete, 'call', _55 => _55(handler)]);
+  }
+  emit(event, ...args) {
+    const set = this.handlers.get(event);
+    if (set) {
+      for (const handler of set) {
+        handler(...args);
+      }
+    }
+  }
+}, _class5);
+
+// src/controller/header-source.ts
+var HeaderSource = class extends TypedEmitter {
+  
+  
+  
+  constructor(options) {
+    super();
+    this.options = options;
+  }
+  fetchDatafile() {
+    if (this.promise) {
+      debugLog("header-source", "Reusing pending refresh");
+      return this.promise;
+    }
+    debugLog("header-source", "Starting refresh");
+    const abortController = new AbortController();
+    this.abortController = abortController;
+    this.promise = fetchDatafile({
+      ...this.options,
+      signal: abortController.signal
+    }).then((data) => {
+      abortController.signal.throwIfAborted();
+      debugLog("header-source", "Refresh completed", {
+        projectId: data.projectId,
+        configUpdatedAt: Number(data.configUpdatedAt),
+        revision: data.revision
+      });
+      this.emit("data", data);
+      return data;
+    }).catch((error) => {
+      debugLog("header-source", "Refresh failed", {
+        aborted: abortController.signal.aborted
+      });
+      throw error;
+    }).finally(() => {
+      if (this.abortController === abortController) {
+        this.promise = void 0;
+        this.abortController = void 0;
+      }
+    });
+    return this.promise;
+  }
+  getUpdatedAtHeader(projectId) {
+    const ctx = getRequestContext();
+    const headerName = _optionalChain([ctx, 'access', _56 => _56.headers, 'optionalAccess', _57 => _57["x-vercel-edge-config-versions"]]) != null ? "x-vercel-edge-config-versions" : "edge-config-versions";
+    const header = _optionalChain([ctx, 'access', _58 => _58.headers, 'optionalAccess', _59 => _59[headerName]]);
+    if (!header) {
+      debugLog("header-source", "Header unavailable", {
+        projectId,
+        reason: "missing-header"
+      });
+      return;
+    }
+    const prefix = `flags_${projectId}=`;
+    const value = _optionalChain([header, 'access', _60 => _60.split, 'call', _61 => _61(";"), 'access', _62 => _62.map, 'call', _63 => _63((part) => part.trim()), 'access', _64 => _64.find, 'call', _65 => _65((part) => part.startsWith(prefix)), 'optionalAccess', _66 => _66.slice, 'call', _67 => _67(prefix.length)]);
+    const timestamp = Number(value);
+    if (!Number.isFinite(timestamp) || timestamp <= 0) {
+      debugLog("header-source", "Header unavailable", {
+        projectId,
+        headerName,
+        reason: value === void 0 ? "project-not-found" : "invalid-timestamp"
+      });
+      return;
+    }
+    debugLog("header-source", "Header version available", {
+      projectId,
+      headerName,
+      timestamp
+    });
+    return timestamp;
+  }
+  async resolveData(currentData) {
+    if (!currentData.configUpdatedAt) {
+      debugLog("header-source", "Skipping header refresh", {
+        projectId: currentData.projectId,
+        reason: "missing-data-timestamp"
+      });
+      return;
+    }
+    const updatedAtHeader = this.getUpdatedAtHeader(currentData.projectId);
+    if (!updatedAtHeader) {
+      return;
+    }
+    const currentUpdatedAt = Number(currentData.configUpdatedAt);
+    const deltaMs = updatedAtHeader - currentUpdatedAt;
+    debugLog("header-source", "Freshness decision", {
+      projectId: currentData.projectId,
+      currentUpdatedAt,
+      headerUpdatedAt: updatedAtHeader,
+      deltaMs,
+      action: updatedAtHeader <= currentUpdatedAt ? "serve-cached" : updatedAtHeader <= currentUpdatedAt + 1e4 ? "background-refresh" : "blocking-refresh"
+    });
+    if (updatedAtHeader <= currentUpdatedAt) {
+      return [currentData, "HIT"];
+    }
+    if (updatedAtHeader <= currentUpdatedAt + 1e4) {
+      const pending = this.fetchDatafile();
+      const signal = _optionalChain([this, 'access', _68 => _68.abortController, 'optionalAccess', _69 => _69.signal]);
+      const background = pending.catch((error) => {
+        if (!_optionalChain([signal, 'optionalAccess', _70 => _70.aborted])) {
+          console.error("@vercel/flags-core: Header refresh failed:", error);
+        }
+      });
+      _functions.waitUntil.call(void 0, background);
+      return [currentData, "STALE"];
+    }
+    const data = await this.fetchDatafile();
+    return [tagData(data, "fetched"), "MISS"];
+  }
+  read(currentData) {
+    return this.resolveData(currentData);
+  }
+  isAvailable(projectId) {
+    return !!this.getUpdatedAtHeader(projectId);
+  }
+  /**
+   * Abort the current header-driven fetch and discard its pending work.
+   */
+  stop() {
+    debugLog("header-source", "Stopping header refresh", {
+      pending: this.promise !== void 0
+    });
+    _optionalChain([this, 'access', _71 => _71.abortController, 'optionalAccess', _72 => _72.abort, 'call', _73 => _73()]);
+    this.abortController = void 0;
+    this.promise = void 0;
+  }
+};
+
 // src/controller/normalized-options.ts
 var DEFAULT_STREAM_INIT_TIMEOUT_MS = 3e3;
 var DEFAULT_POLLING_INTERVAL_MS = 3e4;
@@ -1530,30 +1708,6 @@ function normalizeOptions(options) {
   };
 }
 
-// src/controller/typed-emitter.ts
-var TypedEmitter = (_class5 = class {constructor() { _class5.prototype.__init11.call(this); }
-  __init11() {this.handlers = /* @__PURE__ */ new Map()}
-  on(event, handler) {
-    let set = this.handlers.get(event);
-    if (!set) {
-      set = /* @__PURE__ */ new Set();
-      this.handlers.set(event, set);
-    }
-    set.add(handler);
-  }
-  off(event, handler) {
-    _optionalChain([this, 'access', _47 => _47.handlers, 'access', _48 => _48.get, 'call', _49 => _49(event), 'optionalAccess', _50 => _50.delete, 'call', _51 => _51(handler)]);
-  }
-  emit(event, ...args) {
-    const set = this.handlers.get(event);
-    if (set) {
-      for (const handler of set) {
-        handler(...args);
-      }
-    }
-  }
-}, _class5);
-
 // src/controller/polling-source.ts
 var PollingSource = class extends TypedEmitter {
   
@@ -1568,11 +1722,11 @@ var PollingSource = class extends TypedEmitter {
    * Emits 'data' on success, 'error' on failure.
    */
   async poll() {
-    if (_optionalChain([this, 'access', _52 => _52.abortController, 'optionalAccess', _53 => _53.signal, 'access', _54 => _54.aborted])) return;
+    if (_optionalChain([this, 'access', _74 => _74.abortController, 'optionalAccess', _75 => _75.signal, 'access', _76 => _76.aborted])) return;
     try {
       const data = await fetchDatafile({
         ...this.config,
-        signal: _optionalChain([this, 'access', _55 => _55.abortController, 'optionalAccess', _56 => _56.signal])
+        signal: _optionalChain([this, 'access', _77 => _77.abortController, 'optionalAccess', _78 => _78.signal])
       });
       this.emit("data", data);
     } catch (error) {
@@ -1601,7 +1755,7 @@ var PollingSource = class extends TypedEmitter {
       clearInterval(this.intervalId);
       this.intervalId = void 0;
     }
-    _optionalChain([this, 'access', _57 => _57.abortController, 'optionalAccess', _58 => _58.abort, 'call', _59 => _59()]);
+    _optionalChain([this, 'access', _79 => _79.abortController, 'optionalAccess', _80 => _80.abort, 'call', _81 => _81()]);
     this.abortController = void 0;
   }
 };
@@ -1680,7 +1834,7 @@ async function connectStream(config, callbacks) {
         if (pingTimeoutId !== void 0) clearTimeout(pingTimeoutId);
         if (!initialDataReceived) return;
         pingTimeoutId = setTimeout(() => {
-          _optionalChain([responseBody, 'optionalAccess', _60 => _60.cancel, 'call', _61 => _61(), 'access', _62 => _62.catch, 'call', _63 => _63(() => {
+          _optionalChain([responseBody, 'optionalAccess', _82 => _82.cancel, 'call', _83 => _83(), 'access', _84 => _84.catch, 'call', _85 => _85(() => {
           })]);
           connectionAbort.abort();
         }, PING_TIMEOUT_MS);
@@ -1702,7 +1856,7 @@ async function connectStream(config, callbacks) {
         if (vercelEnv) {
           headers["X-Vercel-Env"] = vercelEnv;
         }
-        const revision = _optionalChain([config, 'access', _64 => _64.revision, 'optionalCall', _65 => _65()]);
+        const revision = _optionalChain([config, 'access', _86 => _86.revision, 'optionalCall', _87 => _87()]);
         if (revision !== void 0) {
           headers["X-Revision"] = String(revision);
         }
@@ -1764,7 +1918,7 @@ async function connectStream(config, callbacks) {
                 resetPingTimeout();
               }
               if (message.type === "primed") {
-                _optionalChain([onPrimed, 'optionalCall', _66 => _66(message)]);
+                _optionalChain([onPrimed, 'optionalCall', _88 => _88(message)]);
                 retryCount = 0;
                 if (!initialDataReceived) {
                   initialDataReceived = true;
@@ -1787,7 +1941,7 @@ async function connectStream(config, callbacks) {
         clearTimeout(pingTimeoutId);
         abortController.signal.removeEventListener("abort", onMainAbort);
         if (!abortController.signal.aborted) {
-          _optionalChain([onDisconnect, 'optionalCall', _67 => _67()]);
+          _optionalChain([onDisconnect, 'optionalCall', _89 => _89()]);
           retryCount++;
           const elapsed = Date.now() - lastAttemptTime;
           const minGap = Math.max(0, BASE_RETRY_DELAY_MS - elapsed);
@@ -1808,7 +1962,7 @@ async function connectStream(config, callbacks) {
         if (!connectionAbort.signal.aborted) {
           lastError = error;
         }
-        _optionalChain([onDisconnect, 'optionalCall', _68 => _68()]);
+        _optionalChain([onDisconnect, 'optionalCall', _90 => _90()]);
         retryCount++;
         const elapsed = Date.now() - lastAttemptTime;
         const minGap = Math.max(0, BASE_RETRY_DELAY_MS - elapsed);
@@ -1839,7 +1993,11 @@ var StreamSource = class extends TypedEmitter {
    * If already started, returns the existing promise.
    */
   start() {
-    if (this.promise) return this.promise;
+    if (this.promise) {
+      debugLog("stream-source", "Reusing stream connection");
+      return this.promise;
+    }
+    debugLog("stream-source", "Starting stream connection");
     const abortController = new AbortController();
     this.abortController = abortController;
     abortController.signal.addEventListener(
@@ -1863,21 +2021,41 @@ var StreamSource = class extends TypedEmitter {
         },
         {
           onDatafile: (newData) => {
+            debugLog("stream-source", "Connected with datafile", {
+              projectId: newData.projectId,
+              configUpdatedAt: Number(newData.configUpdatedAt),
+              revision: newData.revision
+            });
             this.emit("data", newData);
             this.emit("connected");
           },
           onPrimed: (message) => {
+            debugLog("stream-source", "Connected with current revision", {
+              projectId: message.projectId,
+              revision: message.revision
+            });
             this.emit("primed", message);
             this.emit("connected");
           },
           onDisconnect: () => {
+            debugLog("stream-source", "Disconnected", {
+              aborted: abortController.signal.aborted
+            });
             this.emit("disconnected");
           }
         }
       );
-      this.promise = promise;
-      return promise;
+      this.promise = promise.catch((error) => {
+        debugLog("stream-source", "Stream initialization failed", {
+          aborted: abortController.signal.aborted
+        });
+        throw error;
+      });
+      return this.promise;
     } catch (error) {
+      debugLog("stream-source", "Stream initialization failed", {
+        aborted: abortController.signal.aborted
+      });
       this.promise = void 0;
       this.abortController = void 0;
       throw error;
@@ -1887,29 +2065,15 @@ var StreamSource = class extends TypedEmitter {
    * Stop the stream connection.
    */
   stop() {
-    _optionalChain([this, 'access', _69 => _69.abortController, 'optionalAccess', _70 => _70.abort, 'call', _71 => _71()]);
+    debugLog("stream-source", "Stopping stream connection", {
+      active: this.abortController !== void 0
+    });
+    _optionalChain([this, 'access', _91 => _91.abortController, 'optionalAccess', _92 => _92.abort, 'call', _93 => _93()]);
     this.abortController = void 0;
     this.promise = void 0;
   }
 };
 
-// src/controller/tagged-data.ts
-function tagData(data, origin) {
-  return Object.assign(data, { _origin: origin });
-}
-function originToMetricsSource(origin) {
-  switch (origin) {
-    case "stream":
-    case "poll":
-    case "provided":
-      return "in-memory";
-    case "fetched":
-      return "remote";
-    case "bundled":
-      return "embedded";
-  }
-}
-
 // src/controller/index.ts
 function parseConfigUpdatedAt(value) {
   if (typeof value === "number") return value;
@@ -1934,6 +2098,7 @@ var Controller = (_class6 = class {
   
   
   
+  
   // Usage tracking
   
   __init15() {this.isFirstGetData = true}
@@ -1942,17 +2107,18 @@ var Controller = (_class6 = class {
   __init17() {this.buildReadTracked = false}
   // Suppresses usage tracking when the SDK key is unauthorized
   __init18() {this.unauthorized = false}
-  constructor(options) {;_class6.prototype.__init12.call(this);_class6.prototype.__init13.call(this);_class6.prototype.__init14.call(this);_class6.prototype.__init15.call(this);_class6.prototype.__init16.call(this);_class6.prototype.__init17.call(this);_class6.prototype.__init18.call(this);_class6.prototype.__init19.call(this);_class6.prototype.__init20.call(this);_class6.prototype.__init21.call(this);_class6.prototype.__init22.call(this);_class6.prototype.__init23.call(this);_class6.prototype.__init24.call(this);
+  constructor(options) {;_class6.prototype.__init12.call(this);_class6.prototype.__init13.call(this);_class6.prototype.__init14.call(this);_class6.prototype.__init15.call(this);_class6.prototype.__init16.call(this);_class6.prototype.__init17.call(this);_class6.prototype.__init18.call(this);_class6.prototype.__init19.call(this);_class6.prototype.__init20.call(this);_class6.prototype.__init21.call(this);_class6.prototype.__init22.call(this);_class6.prototype.__init23.call(this);_class6.prototype.__init24.call(this);_class6.prototype.__init25.call(this);
     this.options = normalizeOptions(options);
     this.streamSource = new StreamSource(
       this.options,
-      () => _optionalChain([this, 'access', _72 => _72.data, 'optionalAccess', _73 => _73.revision])
+      () => _optionalChain([this, 'access', _94 => _94.data, 'optionalAccess', _95 => _95.revision])
     );
     this.pollingSource = new PollingSource(this.options);
     this.bundledSource = new BundledSource({
       auth: this.options.auth,
       readBundledDefinitions
     });
+    this.headerSource = new HeaderSource(this.options);
     this.wireSourceEvents();
     if (this.options.datafile) {
       this.data = tagData(this.options.datafile, "provided");
@@ -1988,6 +2154,11 @@ var Controller = (_class6 = class {
   __init24() {this.onPollError = (error) => {
     console.error("@vercel/flags-core: Poll failed:", error);
   }}
+  __init25() {this.onFetchedData = (data) => {
+    if (this.isNewerData(data)) {
+      this.data = tagData(data, "fetched");
+    }
+  }}
   // ---------------------------------------------------------------------------
   // Source event wiring
   // ---------------------------------------------------------------------------
@@ -1998,6 +2169,7 @@ var Controller = (_class6 = class {
     this.streamSource.on("disconnected", this.onStreamDisconnected);
     this.pollingSource.on("data", this.onPollData);
     this.pollingSource.on("error", this.onPollError);
+    this.headerSource.on("data", this.onFetchedData);
   }
   unwireSourceEvents() {
     this.streamSource.off("data", this.onStreamData);
@@ -2006,11 +2178,18 @@ var Controller = (_class6 = class {
     this.streamSource.off("disconnected", this.onStreamDisconnected);
     this.pollingSource.off("data", this.onPollData);
     this.pollingSource.off("error", this.onPollError);
+    this.headerSource.off("data", this.onFetchedData);
   }
   // ---------------------------------------------------------------------------
   // State machine
   // ---------------------------------------------------------------------------
   transition(to) {
+    debugLog("controller", "State changed", {
+      from: this.state,
+      to,
+      projectId: _optionalChain([this, 'access', _96 => _96.data, 'optionalAccess', _97 => _97.projectId]),
+      origin: _optionalChain([this, 'access', _98 => _98.data, 'optionalAccess', _99 => _99._origin])
+    });
     this.state = to;
   }
   get isConnected() {
@@ -2023,6 +2202,8 @@ var Controller = (_class6 = class {
         return "streaming";
       case "polling":
         return "polling";
+      case "vercel":
+        return "vercel";
       default:
         return "offline";
     }
@@ -2039,6 +2220,14 @@ var Controller = (_class6 = class {
    * Offline mode (neither): datafile → bundled → one-time fetch
    */
   async initialize() {
+    debugLog("controller", "Initializing", {
+      buildStep: this.options.buildStep,
+      streamEnabled: this.options.stream.enabled,
+      pollingEnabled: this.options.polling.enabled,
+      hasData: this.data !== void 0,
+      projectId: _optionalChain([this, 'access', _100 => _100.data, 'optionalAccess', _101 => _101.projectId]),
+      origin: _optionalChain([this, 'access', _102 => _102.data, 'optionalAccess', _103 => _103._origin])
+    });
     if (this.options.buildStep) {
       this.transition("build:loading");
       await this.initializeForBuildStep();
@@ -2058,7 +2247,9 @@ var Controller = (_class6 = class {
       }
     }
     if (this.data) {
-      if (this.options.stream.enabled) {
+      if (this.headerSource.isAvailable(this.data.projectId)) {
+        this.transition("vercel");
+      } else if (this.options.stream.enabled) {
         this.transition("initializing:stream");
         await this.tryInitializeStream();
       } else if (this.options.polling.enabled) {
@@ -2069,6 +2260,9 @@ var Controller = (_class6 = class {
       }
       return;
     }
+    debugLog("controller", "Header mode unavailable", {
+      reason: "no-definitions"
+    });
     if (this.options.stream.enabled) {
       this.transition("initializing:stream");
       const streamSuccess = await this.tryInitializeStream();
@@ -2097,6 +2291,15 @@ var Controller = (_class6 = class {
     const [result, cacheStatus] = await this.resolveData();
     const readMs = Date.now() - startTime;
     const source = originToMetricsSource(result._origin);
+    debugLog("controller", "Read resolved", {
+      projectId: result.projectId,
+      mode: this.mode,
+      source,
+      origin: result._origin,
+      cacheStatus,
+      configUpdatedAt: parseConfigUpdatedAt(result.configUpdatedAt),
+      revision: result.revision
+    });
     this.trackRead(startTime, cacheHadDefinitions, isFirstRead, source);
     if (this.dataViewSource !== result) {
       const { _origin, ...rest } = result;
@@ -2121,6 +2324,7 @@ var Controller = (_class6 = class {
     this.unwireSourceEvents();
     this.streamSource.stop();
     this.pollingSource.stop();
+    this.headerSource.stop();
     this.data = this.options.datafile ? tagData(this.options.datafile, "provided") : void 0;
     this.transition("shutdown");
     await this.usageTracker.shutdown();
@@ -2164,6 +2368,15 @@ var Controller = (_class6 = class {
       }
     }
     const source = originToMetricsSource(result._origin);
+    debugLog("controller", "Datafile resolved", {
+      projectId: result.projectId,
+      mode: this.mode,
+      source,
+      origin: result._origin,
+      cacheStatus,
+      configUpdatedAt: parseConfigUpdatedAt(result.configUpdatedAt),
+      revision: result.revision
+    });
     if (this.dataViewSource !== result) {
       const { _origin, ...rest } = result;
       this.dataViewBase = rest;
@@ -2202,6 +2415,12 @@ var Controller = (_class6 = class {
       return this.resolveDataForBuildStep();
     }
     if (this.data) {
+      if (this.mode === "vercel") {
+        const result = await this.headerSource.read(this.data);
+        if (result) {
+          return result;
+        }
+      }
       const cacheStatus = this.isConnected ? "HIT" : "STALE";
       return [this.data, cacheStatus];
     }
@@ -2240,6 +2459,14 @@ var Controller = (_class6 = class {
       ]);
       clearTimeout(timeoutId);
       if (result === "timeout") {
+        debugLog(
+          "controller",
+          "Stream initialization timed out; using fallback",
+          {
+            timeoutMs: this.options.stream.initTimeoutMs,
+            origin: _optionalChain([this, 'access', _104 => _104.data, 'optionalAccess', _105 => _105._origin])
+          }
+        );
         console.warn(
           "@vercel/flags-core: Stream initialization timeout, falling back while continuing to connect in the background"
         );
@@ -2488,11 +2715,11 @@ var Controller = (_class6 = class {
       duration: Date.now() - startTime,
       mode: mode === "streaming" ? "stream" : mode === "polling" ? "poll" : mode
     };
-    const configUpdatedAt = _optionalChain([this, 'access', _74 => _74.data, 'optionalAccess', _75 => _75.configUpdatedAt]);
+    const configUpdatedAt = _optionalChain([this, 'access', _106 => _106.data, 'optionalAccess', _107 => _107.configUpdatedAt]);
     if (typeof configUpdatedAt === "number") {
       trackOptions.configUpdatedAt = configUpdatedAt;
     }
-    const revision = _optionalChain([this, 'access', _76 => _76.data, 'optionalAccess', _77 => _77.revision]);
+    const revision = _optionalChain([this, 'access', _108 => _108.data, 'optionalAccess', _109 => _109.revision]);
     if (typeof revision === "number") {
       trackOptions.revision = revision;
     }
@@ -2683,4 +2910,4 @@ var { flagsClient, resetDefaultFlagsClient, createClient } = make(
 
 
 exports.ResolutionReason = ResolutionReason; exports.evaluate = evaluate; exports.FallbackNotFoundError = FallbackNotFoundError; exports.FallbackEntryNotFoundError = FallbackEntryNotFoundError; exports.Controller = Controller; exports.flagsClient = flagsClient; exports.resetDefaultFlagsClient = resetDefaultFlagsClient; exports.createClient = createClient;
-//# sourceMappingURL=chunk-CKL562EU.cjs.map
+//# sourceMappingURL=chunk-ZUO5MVUD.cjs.map