@vercel/flags-core 1.8.1 → 1.8.2-d31aae4-20260916165712

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @vercel/flags-core
 
+## 1.8.2-d31aae4-20260916165712
+
+### Patch Changes
+
+- [#497](https://github.com/vercel/flags/pull/497) [`4848877`](https://github.com/vercel/flags/commit/4848877ca60c8595745b7759e351e936d7fe5889) Thanks [@feugy](https://github.com/feugy)! - Allow passing a custom `waitUntil` function to `createClient` for background
+  usage and exposure reporting. Pending exposure reports are drained by
+  `client.shutdown()`. The Next.js conditional export uses `after` from
+  `next/server` by default.
+
+- [#490](https://github.com/vercel/flags/pull/490) [`559c1e7`](https://github.com/vercel/flags/commit/559c1e7bb14765acb234bf004c8e839fadfc2922) Thanks [@AndyBitz](https://github.com/AndyBitz)! - Use the runtime-provided ingest transport when available
+
 ## 1.8.1
 
 ### Patch Changes

package/README.md

@@ -12,18 +12,27 @@ npm i @vercel/flags-core
 
 ## Usage
 
+Create a shared client at module scope, but evaluate flags inside a request handler when using Vercel OIDC authentication. `evaluate()` and `bulkEvaluate()` initialize the client automatically on first use; you do not need to call `initialize()` first.
+
+For example, in an Express app deployed to Vercel:
+
 ```ts
+import express from 'express';
 import { createClient } from '@vercel/flags-core';
 
-const client = createClient(process.env.FLAGS!);
-
-await client.initialize();
+const app = express();
+const client = createClient(); // Uses Vercel OIDC; does not initialize yet.
 
-const result = await client.evaluate<boolean>('show-new-feature', false, {
-  user: { id: 'user-123' },
+app.get('/api/feature', async (_req, res) => {
+  const result = await client.evaluate<boolean>('show-new-feature', false);
+  res.json({ enabled: result.value });
 });
+
+export default app;
 ```
 
+Outside Vercel, pass an SDK key explicitly: `createClient(process.env.FLAGS)`.
+
 ## Evaluation Metrics
 
 To associate evaluation metrics with an environment, pass the

package/dist/{chunk-CVDAHZHK.cjs → chunk-2WO37TKH.cjs}

@@ -4,6 +4,9 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/index.default.ts
+var _functions = require('@vercel/functions');
+
 // src/controller-fns.ts
 var controller_fns_exports = {};
 __export(controller_fns_exports, {
@@ -573,7 +576,7 @@ function bulkEvaluate(flags, shared) {
 }
 
 // package.json
-var version = "1.8.1";
+var version = "1.8.2-d31aae4-20260916165712";
 
 // src/lib/report-value.ts
 function internalReportValue(key, value, data) {
@@ -792,7 +795,7 @@ async function bulkEvaluate2(id, flags, entities) {
 }
 
 // src/create-raw-client.ts
-var _functions = require('@vercel/functions');
+
 var _lite = require('dequal/lite');
 var idCount = 0;
 async function performInitialize(instance, initFn) {
@@ -808,9 +811,11 @@ function createCreateRawClient(fns) {
   return function createRawClient({
     controller,
     origin,
-    experimental_reportExposures
+    experimental_reportExposures,
+    waitUntil: waitUntil3 = _functions.waitUntil
   }) {
     const id = idCount++;
+    const pendingExposureReports = /* @__PURE__ */ new Set();
     controllerInstanceMap.set(id, {
       controller,
       initialized: false,
@@ -828,8 +833,10 @@ function createCreateRawClient(fns) {
           );
         }
       })();
+      pendingExposureReports.add(pending);
+      void pending.finally(() => pendingExposureReports.delete(pending));
       try {
-        _functions.waitUntil.call(void 0, pending);
+        waitUntil3(pending);
       } catch (e) {
       }
     }
@@ -864,6 +871,9 @@ function createCreateRawClient(fns) {
       },
       shutdown: async () => {
         await fns.shutdown(id);
+        while (pendingExposureReports.size > 0) {
+          await Promise.all(pendingExposureReports);
+        }
         controllerInstanceMap.delete(id);
       },
       getDatafile: async () => {
@@ -1045,12 +1055,23 @@ function getJitteredWaitMs(baseMs, ratio) {
   return Math.floor(min + Math.random() * span);
 }
 
+// src/utils/runtime-ingest.ts
+var FLAGS_CONTEXT_SYMBOL = /* @__PURE__ */ Symbol.for("@vercel/flags-context");
+function getRuntimeIngest() {
+  try {
+    const context = globalThis[FLAGS_CONTEXT_SYMBOL];
+    return typeof _optionalChain([context, 'optionalAccess', _31 => _31.ingest]) === "function" ? context.ingest : void 0;
+  } catch (e5) {
+    return void 0;
+  }
+}
+
 // src/utils/ingest.ts
 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 isDebugMode = _optionalChain([process, 'access', _32 => _32.env, 'access', _33 => _33.DEBUG, 'optionalAccess', _34 => _34.includes, 'call', _35 => _35("@vercel/flags-core")]);
 var debugLog = (...args) => {
   if (!isDebugMode) return;
   console.log(...args);
@@ -1059,7 +1080,7 @@ async function getEvaluatingOidcToken(auth) {
   if (!auth.sdkKey) return void 0;
   try {
     return await _oidc.getVercelOidcToken.call(void 0, );
-  } catch (e5) {
+  } catch (e6) {
     return void 0;
   }
 }
@@ -1078,8 +1099,28 @@ async function getIngestHeaders(options, flushReason) {
     ...isDebugMode ? { "x-vercel-debug-ingest": "1" } : null
   };
 }
+function getRuntimeIngestHeaders(options, flushReason) {
+  return {
+    "Content-Type": "application/json",
+    ...options.auth.sdkKey ? { Authorization: `Bearer ${options.auth.sdkKey}` } : null,
+    "User-Agent": `VercelFlagsCore/${version}`,
+    [FLUSH_REASON_HEADER]: flushReason,
+    ..._nullishCoalesce(options.metricEnvironment, () => ( process.env.VERCEL_ENV)) ? {
+      "X-Vercel-Env": _nullishCoalesce(options.metricEnvironment, () => ( process.env.VERCEL_ENV))
+    } : null,
+    ...isDebugMode ? { "x-vercel-debug-ingest": "1" } : null
+  };
+}
 async function sendIngestEvents(options, events, flushId, flushReason) {
-  const eventsToSend = events.map((event) => event.ingestEvent());
+  let eventsToSend = events.map((event) => event.ingestEvent());
+  const runtimeIngest = getRuntimeIngest();
+  if (runtimeIngest) {
+    const headers = getRuntimeIngestHeaders(options, flushReason);
+    eventsToSend = eventsToSend.filter(
+      (event) => !runtimeIngest({ headers, body: [event] })
+    );
+    if (eventsToSend.length === 0) return;
+  }
   for (let i = 0; i < eventsToSend.length; i += MAX_EVENTS_PER_REQUEST) {
     await sendIngestChunk(
       options,
@@ -1129,7 +1170,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', _36 => _36[SYMBOL_FOR_REQ_CONTEXT], 'optionalAccess', _37 => _37.get, 'optionalCall', _38 => _38()]);
     if (ctx && Object.hasOwn(ctx, "headers")) {
       return {
         ctx,
@@ -1137,7 +1178,7 @@ function getRequestContext() {
       };
     }
     return { ctx, headers: void 0 };
-  } catch (e6) {
+  } catch (e7) {
     return { ctx: void 0, headers: void 0 };
   }
 }
@@ -1148,10 +1189,12 @@ var IDLE_FLUSH_WAIT_MS = 5e3;
 var IDLE_FLUSH_JITTER_RATIO = 0.2;
 var MAX_FLUSH_WAIT_MS = 6e4;
 var Scheduler = (_class = class {
-  constructor(onFlush) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);
+  constructor(onFlush, scheduleTask = _functions.waitUntil) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);
     this.onFlush = onFlush;
+    this.scheduleTask = scheduleTask;
   }
   
+  
   __init() {this.resolveWait = null}
   __init2() {this.pending = null}
   __init3() {this.idleTimeout = null}
@@ -1166,8 +1209,8 @@ var Scheduler = (_class = class {
         await this.onFlush(reason);
       })();
       try {
-        _functions.waitUntil.call(void 0, this.pending);
-      } catch (e7) {
+        this.scheduleTask(this.pending);
+      } catch (e8) {
       }
       this.maxTimeout = setTimeout(
         () => this.resolveScheduledFlush("max_timeout"),
@@ -1194,7 +1237,7 @@ var Scheduler = (_class = class {
   }
   resolveScheduledFlush(reason) {
     this.clearTimeouts();
-    _optionalChain([this, 'access', _38 => _38.resolveWait, 'optionalCall', _39 => _39(reason)]);
+    _optionalChain([this, 'access', _39 => _39.resolveWait, 'optionalCall', _40 => _40(reason)]);
   }
   reset() {
     this.pending = null;
@@ -1313,12 +1356,18 @@ var UsageTracker = (_class4 = class {
   __init7() {this.flushCount = 0}
   
   
-  __init8() {this.trackedRequests = /* @__PURE__ */ new WeakSet()}
-  __init9() {this.readEvents = []}
-  __init10() {this.evaluationEvents = /* @__PURE__ */ new Map()}
-  constructor(options) {;_class4.prototype.__init7.call(this);_class4.prototype.__init8.call(this);_class4.prototype.__init9.call(this);_class4.prototype.__init10.call(this);
+  
+  __init8() {this.inflightFlushes = /* @__PURE__ */ new Set()}
+  __init9() {this.trackedRequests = /* @__PURE__ */ new WeakSet()}
+  __init10() {this.readEvents = []}
+  __init11() {this.evaluationEvents = /* @__PURE__ */ new Map()}
+  constructor(options) {;_class4.prototype.__init7.call(this);_class4.prototype.__init8.call(this);_class4.prototype.__init9.call(this);_class4.prototype.__init10.call(this);_class4.prototype.__init11.call(this);
     this.options = options;
-    this.scheduler = new Scheduler((reason) => this.flushEvents(reason));
+    this.waitUntil = options.waitUntil;
+    this.scheduler = new Scheduler(
+      (reason) => this.flushEvents(reason),
+      options.waitUntil
+    );
   }
   /**
    * Triggers an immediate flush of any pending events.
@@ -1327,6 +1376,7 @@ var UsageTracker = (_class4 = class {
   async shutdown() {
     await this.scheduler.shutdown();
     await this.flushEvents("shutdown");
+    await Promise.all([...this.inflightFlushes]);
   }
   /**
    * Tracks a config read event. Deduplicates by request context.
@@ -1338,7 +1388,7 @@ var UsageTracker = (_class4 = class {
       if (this.trackedRequests.has(ctx)) return;
       this.trackedRequests.add(ctx);
       this.readEvents.push(new FlagsConfigReadEvent(headers, options));
-      this.scheduler.scheduleFlush();
+      this.requestFlush();
     } catch (error) {
       console.error("@vercel/flags-core: Failed to record event:", error);
     }
@@ -1362,7 +1412,7 @@ var UsageTracker = (_class4 = class {
           new FlagsEvaluationEvent(bucketedOptions)
         );
       }
-      this.scheduler.scheduleFlush();
+      this.requestFlush();
     } catch (error) {
       console.error(
         "@vercel/flags-core: Failed to record evaluation event:",
@@ -1370,6 +1420,25 @@ var UsageTracker = (_class4 = class {
       );
     }
   }
+  /**
+   * Flushes immediately when the runtime provides an ingest transport,
+   * otherwise falls back to the time-based scheduler.
+   */
+  requestFlush() {
+    if (getRuntimeIngest()) {
+      const flush = this.flushEvents("immediate").catch((error) => {
+        console.error("@vercel/flags-core: Failed to flush events:", error);
+      });
+      this.inflightFlushes.add(flush);
+      void flush.finally(() => this.inflightFlushes.delete(flush));
+      try {
+        _optionalChain([this, 'access', _41 => _41.waitUntil, 'optionalCall', _42 => _42(flush)]);
+      } catch (e9) {
+      }
+    } else {
+      this.scheduler.scheduleFlush();
+    }
+  }
   /**
    * Send all events to the ingest service
    */
@@ -1442,7 +1511,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', _43 => _43.state]) === "ok" && result.definitions) {
       return result.definitions;
     }
     return void 0;
@@ -1482,19 +1551,20 @@ 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', _44 => _44.signal, 'optionalAccess', _45 => _45.removeEventListener, 'call', _46 => _46("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', _47 => _47.signal, 'optionalAccess', _48 => _48.removeEventListener, 'call', _49 => _49("abort", onExternalAbort)]);
     throw error instanceof Error ? error : new Error("Unknown fetch error");
   }
 }
 
 // src/controller/normalized-options.ts
+
 var DEFAULT_STREAM_INIT_TIMEOUT_MS = 3e3;
 var DEFAULT_POLLING_INTERVAL_MS = 3e4;
 var MIN_POLLING_INTERVAL_MS = 3e4;
@@ -1538,6 +1608,7 @@ function normalizeOptions(options) {
     polling,
     buildStep,
     fetch: _nullishCoalesce(options.fetch, () => ( globalThis.fetch)),
+    waitUntil: _nullishCoalesce(options.waitUntil, () => ( _functions.waitUntil)),
     host: "https://flags.vercel.com",
     metricEnvironment: options.metricEnvironment,
     clientName: options.clientName,
@@ -1546,8 +1617,8 @@ function normalizeOptions(options) {
 }
 
 // src/controller/typed-emitter.ts
-var TypedEmitter = (_class5 = class {constructor() { _class5.prototype.__init11.call(this); }
-  __init11() {this.handlers = /* @__PURE__ */ new Map()}
+var TypedEmitter = (_class5 = class {constructor() { _class5.prototype.__init12.call(this); }
+  __init12() {this.handlers = /* @__PURE__ */ new Map()}
   on(event, handler) {
     let set = this.handlers.get(event);
     if (!set) {
@@ -1557,7 +1628,7 @@ var TypedEmitter = (_class5 = class {constructor() { _class5.prototype.__init11.
     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)]);
+    _optionalChain([this, 'access', _50 => _50.handlers, 'access', _51 => _51.get, 'call', _52 => _52(event), 'optionalAccess', _53 => _53.delete, 'call', _54 => _54(handler)]);
   }
   emit(event, ...args) {
     const set = this.handlers.get(event);
@@ -1583,11 +1654,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', _55 => _55.abortController, 'optionalAccess', _56 => _56.signal, 'access', _57 => _57.aborted])) return;
     try {
       const data = await fetchDatafile({
         ...this.config,
-        signal: _optionalChain([this, 'access', _55 => _55.abortController, 'optionalAccess', _56 => _56.signal])
+        signal: _optionalChain([this, 'access', _58 => _58.abortController, 'optionalAccess', _59 => _59.signal])
       });
       this.emit("data", data);
     } catch (error) {
@@ -1616,7 +1687,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', _60 => _60.abortController, 'optionalAccess', _61 => _61.abort, 'call', _62 => _62()]);
     this.abortController = void 0;
   }
 };
@@ -1695,7 +1766,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', _63 => _63.cancel, 'call', _64 => _64(), 'access', _65 => _65.catch, 'call', _66 => _66(() => {
           })]);
           connectionAbort.abort();
         }, PING_TIMEOUT_MS);
@@ -1717,7 +1788,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', _67 => _67.revision, 'optionalCall', _68 => _68()]);
         if (revision !== void 0) {
           headers["X-Revision"] = String(revision);
         }
@@ -1763,7 +1834,7 @@ async function connectStream(config, callbacks) {
               let message;
               try {
                 message = JSON.parse(line);
-              } catch (e8) {
+              } catch (e10) {
                 console.warn(
                   "@vercel/flags-core: Failed to parse stream message, skipping"
                 );
@@ -1779,7 +1850,7 @@ async function connectStream(config, callbacks) {
                 resetPingTimeout();
               }
               if (message.type === "primed") {
-                _optionalChain([onPrimed, 'optionalCall', _66 => _66(message)]);
+                _optionalChain([onPrimed, 'optionalCall', _69 => _69(message)]);
                 retryCount = 0;
                 if (!initialDataReceived) {
                   initialDataReceived = true;
@@ -1802,7 +1873,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', _70 => _70()]);
           retryCount++;
           const elapsed = Date.now() - lastAttemptTime;
           const minGap = Math.max(0, BASE_RETRY_DELAY_MS - elapsed);
@@ -1823,7 +1894,7 @@ async function connectStream(config, callbacks) {
         if (!connectionAbort.signal.aborted) {
           lastError = error;
         }
-        _optionalChain([onDisconnect, 'optionalCall', _68 => _68()]);
+        _optionalChain([onDisconnect, 'optionalCall', _71 => _71()]);
         retryCount++;
         const elapsed = Date.now() - lastAttemptTime;
         const minGap = Math.max(0, BASE_RETRY_DELAY_MS - elapsed);
@@ -1902,7 +1973,7 @@ var StreamSource = class extends TypedEmitter {
    * Stop the stream connection.
    */
   stop() {
-    _optionalChain([this, 'access', _69 => _69.abortController, 'optionalAccess', _70 => _70.abort, 'call', _71 => _71()]);
+    _optionalChain([this, 'access', _72 => _72.abortController, 'optionalAccess', _73 => _73.abort, 'call', _74 => _74()]);
     this.abortController = void 0;
     this.promise = void 0;
   }
@@ -1937,31 +2008,31 @@ function parseConfigUpdatedAt(value) {
 var Controller = (_class6 = class {
   
   // State machine
-  __init12() {this.state = "idle"}
+  __init13() {this.state = "idle"}
   // Data state — tagged with origin
   
   // Memoized data spread for read() / getDatafile().
   // Rebuilt only when `this.data` reference changes (e.g. on stream/poll update).
   // Holds the result of stripping `_origin`; metrics are appended per-call.
-  __init13() {this.dataViewSource = void 0}
-  __init14() {this.dataViewBase = void 0}
+  __init14() {this.dataViewSource = void 0}
+  __init15() {this.dataViewBase = void 0}
   // Sources (I/O delegates)
   
   
   
   // Usage tracking
   
-  __init15() {this.isFirstGetData = true}
+  __init16() {this.isFirstGetData = true}
   // Build-step deduplication
-  __init16() {this.buildDataPromise = null}
-  __init17() {this.buildReadTracked = false}
+  __init17() {this.buildDataPromise = null}
+  __init18() {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);
+  __init19() {this.unauthorized = false}
+  constructor(options) {;_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', _75 => _75.data, 'optionalAccess', _76 => _76.revision])
     );
     this.pollingSource = new PollingSource(this.options);
     this.bundledSource = new BundledSource({
@@ -1975,32 +2046,32 @@ var Controller = (_class6 = class {
     this.usageTracker = new UsageTracker(this.options);
   }
   // Source event handlers (stored for cleanup)
-  __init19() {this.onStreamData = (data) => {
+  __init20() {this.onStreamData = (data) => {
     if (this.isNewerData(data)) {
       this.data = tagData(data, "stream");
     }
   }}
-  __init20() {this.onStreamPrimed = () => {
+  __init21() {this.onStreamPrimed = () => {
     if (this.state === "degraded" || this.state === "initializing:stream") {
       this.transition("streaming");
     }
   }}
-  __init21() {this.onStreamConnected = () => {
+  __init22() {this.onStreamConnected = () => {
     if (this.state === "degraded" || this.state === "initializing:stream") {
       this.transition("streaming");
     }
   }}
-  __init22() {this.onStreamDisconnected = () => {
+  __init23() {this.onStreamDisconnected = () => {
     if (this.state === "streaming") {
       this.transition("degraded");
     }
   }}
-  __init23() {this.onPollData = (data) => {
+  __init24() {this.onPollData = (data) => {
     if (this.isNewerData(data)) {
       this.data = tagData(data, "poll");
     }
   }}
-  __init24() {this.onPollError = (error) => {
+  __init25() {this.onPollError = (error) => {
     console.error("@vercel/flags-core: Poll failed:", error);
   }}
   // ---------------------------------------------------------------------------
@@ -2069,7 +2140,7 @@ var Controller = (_class6 = class {
         if (bundled) {
           this.data = tagData(bundled, "bundled");
         }
-      } catch (e9) {
+      } catch (e11) {
       }
     }
     if (this.data) {
@@ -2171,7 +2242,7 @@ var Controller = (_class6 = class {
           this.data = tagData(fetched, "fetched");
           result = this.data;
           cacheStatus = "MISS";
-        } catch (e10) {
+        } catch (e12) {
           throw new Error(
             "@vercel/flags-core: No flag definitions available. Initialize the client or provide a datafile."
           );
@@ -2290,7 +2361,7 @@ var Controller = (_class6 = class {
           return true;
         }
         return false;
-      } catch (e11) {
+      } catch (e13) {
         return false;
       }
     }
@@ -2315,7 +2386,7 @@ var Controller = (_class6 = class {
         return true;
       }
       return false;
-    } catch (e12) {
+    } catch (e14) {
       clearTimeout(timeoutId);
       return false;
     }
@@ -2365,7 +2436,7 @@ var Controller = (_class6 = class {
         fetch: this.options.fetch
       });
       return tagData(fetched, "fetched");
-    } catch (e13) {
+    } catch (e15) {
     }
     throw new Error(
       "@vercel/flags-core: No flag definitions available during build. Provide a datafile or bundled definitions."
@@ -2399,7 +2470,7 @@ var Controller = (_class6 = class {
         this.data = tagData(fetched, "fetched");
         this.transition("degraded");
         return;
-      } catch (e14) {
+      } catch (e16) {
       }
     }
     throw new Error(
@@ -2451,7 +2522,7 @@ var Controller = (_class6 = class {
         this.data = tagData(fetched, "fetched");
         this.transition("degraded");
         return [this.data, "MISS"];
-      } catch (e15) {
+      } catch (e17) {
       }
     }
     throw new Error(
@@ -2503,11 +2574,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', _77 => _77.data, 'optionalAccess', _78 => _78.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', _79 => _79.data, 'optionalAccess', _80 => _80.revision]);
     if (typeof revision === "number") {
       trackOptions.revision = revision;
     }
@@ -2540,7 +2611,7 @@ function parseSdkKeyFromFlagsConnectionString(text) {
     const params = new URLSearchParams(text.slice(6));
     const sdkKey = params.get("sdkKey");
     if (sdkKey && SDK_KEY_REGEX.test(sdkKey)) return sdkKey;
-  } catch (e16) {
+  } catch (e18) {
   }
   return null;
 }
@@ -2549,7 +2620,7 @@ function parseSdkKeyFromFlagsConnectionString(text) {
 async function getOidcToken() {
   try {
     return await _oidc.getVercelOidcToken.call(void 0, );
-  } catch (e17) {
+  } catch (e19) {
     throw new Error(
       [
         "@vercel/flags-core: Failed to get OIDC token.",
@@ -2611,7 +2682,7 @@ var Authentication = class {
 };
 
 // src/index.make.ts
-function make(createRawClient) {
+function make(createRawClient, defaults) {
   let _defaultFlagsClient = null;
   function createClient2(sdkKeyOrConnectionStringOrOptions, options) {
     const optionsOnly = typeof sdkKeyOrConnectionStringOrOptions === "object" && sdkKeyOrConnectionStringOrOptions !== null;
@@ -2619,10 +2690,16 @@ function make(createRawClient) {
     const createClientOptions = optionsOnly ? sdkKeyOrConnectionStringOrOptions : options;
     const { experimental_reportExposures, ...controllerOptions } = _nullishCoalesce(createClientOptions, () => ( {}));
     const auth = new Authentication(sdkKeyOrConnectionString);
-    const controller = new Controller({ auth, ...controllerOptions });
+    const waitUntil3 = _nullishCoalesce(controllerOptions.waitUntil, () => ( defaults.waitUntil));
+    const controller = new Controller({
+      auth,
+      ...controllerOptions,
+      waitUntil: waitUntil3
+    });
     return createRawClient({
       controller,
       origin: { provider: "vercel", sdkKey: auth.sdkKey },
+      waitUntil: waitUntil3,
       ...experimental_reportExposures ? { experimental_reportExposures } : {}
     });
   }
@@ -2661,7 +2738,7 @@ var {
    * Create a flags client using an SDK key, connection string, or Vercel OIDC.
    */
   createClient
-} = make(createCreateRawClient(controller_fns_exports));
+} = make(createCreateRawClient(controller_fns_exports), { waitUntil: _functions.waitUntil });
 
 
 
@@ -2673,4 +2750,4 @@ var {
 
 
 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-CVDAHZHK.cjs.map
+//# sourceMappingURL=chunk-2WO37TKH.cjs.map