@vercel/flags-core 1.8.1 → 1.8.2

package/dist/{chunk-5BWCBI7I.js → chunk-AMDRNXFQ.js}

@@ -4,6 +4,9 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/index.default.ts
+import { waitUntil as waitUntil2 } from "@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";
 
 // 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
-import { waitUntil } from "@vercel/functions";
+import { waitUntil as defaultWaitUntil } from "@vercel/functions";
 import { dequal } from "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 = defaultWaitUntil
   }) {
     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 {
-        waitUntil(pending);
+        waitUntil3(pending);
       } catch {
       }
     }
@@ -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,6 +1055,17 @@ 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 context?.ingest === "function" ? context.ingest : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
 // src/utils/ingest.ts
 var MAX_RETRIES = 3;
 var MAX_EVENTS_PER_REQUEST = 2e3;
@@ -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,
+    ...options.metricEnvironment ?? process.env.VERCEL_ENV ? {
+      "X-Vercel-Env": 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,
@@ -1143,15 +1184,17 @@ function getRequestContext() {
 }
 
 // src/utils/scheduler.ts
-import { waitUntil as waitUntil2 } from "@vercel/functions";
+import { waitUntil } from "@vercel/functions";
 var IDLE_FLUSH_WAIT_MS = 5e3;
 var IDLE_FLUSH_JITTER_RATIO = 0.2;
 var MAX_FLUSH_WAIT_MS = 6e4;
 var Scheduler = class {
-  constructor(onFlush) {
+  constructor(onFlush, scheduleTask = waitUntil) {
     this.onFlush = onFlush;
+    this.scheduleTask = scheduleTask;
   }
   onFlush;
+  scheduleTask;
   resolveWait = null;
   pending = null;
   idleTimeout = null;
@@ -1166,7 +1209,7 @@ var Scheduler = class {
         await this.onFlush(reason);
       })();
       try {
-        waitUntil2(this.pending);
+        this.scheduleTask(this.pending);
       } catch {
       }
       this.maxTimeout = setTimeout(
@@ -1313,12 +1356,18 @@ var UsageTracker = class {
   flushCount = 0;
   options;
   scheduler;
+  waitUntil;
+  inflightFlushes = /* @__PURE__ */ new Set();
   trackedRequests = /* @__PURE__ */ new WeakSet();
   readEvents = [];
   evaluationEvents = /* @__PURE__ */ new Map();
   constructor(options) {
     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 = 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 = 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 = 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 = 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 {
+        this.waitUntil?.(flush);
+      } catch {
+      }
+    } else {
+      this.scheduler.scheduleFlush();
+    }
+  }
   /**
    * Send all events to the ingest service
    */
@@ -1495,6 +1564,7 @@ async function fetchDatafile(options) {
 }
 
 // src/controller/normalized-options.ts
+import { waitUntil as defaultWaitUntil2 } from "@vercel/functions";
 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: options.fetch ?? globalThis.fetch,
+    waitUntil: options.waitUntil ?? defaultWaitUntil2,
     host: "https://flags.vercel.com",
     metricEnvironment: options.metricEnvironment,
     clientName: options.clientName,
@@ -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 } = createClientOptions ?? {};
     const auth = new Authentication(sdkKeyOrConnectionString);
-    const controller = new Controller({ auth, ...controllerOptions });
+    const waitUntil3 = 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: waitUntil2 });
 
 export {
   ResolutionReason,
@@ -2673,4 +2750,4 @@ export {
   resetDefaultFlagsClient,
   createClient
 };
-//# sourceMappingURL=chunk-5BWCBI7I.js.map
+//# sourceMappingURL=chunk-AMDRNXFQ.js.map