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

package/dist/{chunk-DAWMMLXD.js → chunk-ZUA6TEG3.js}

@@ -56,7 +56,7 @@ function getSplitBoundaries(outcome) {
 function getCompiledRegex(rhs) {
   const cached = compiledRegexCache.get(rhs);
   if (cached) return cached;
-  const compiled = new RegExp(rhs.pattern, rhs.flags.replace(/[gy]/, ""));
+  const compiled = new RegExp(rhs.pattern, rhs.flags.replace(/[gy]/g, ""));
   compiledRegexCache.set(rhs, compiled);
   return compiled;
 }
@@ -559,7 +559,7 @@ function bulkEvaluate(flags, shared) {
 }
 
 // package.json
-var version = "1.8.2-d31aae4-20260916165712";
+var version = "1.8.3";
 
 // src/lib/report-value.ts
 function internalReportValue(key, value, data) {
@@ -1509,40 +1509,86 @@ var BundledSource = class {
 
 // src/controller/fetch-datafile.ts
 var DEFAULT_FETCH_TIMEOUT_MS = 1e4;
+var DEFAULT_MAX_ATTEMPTS = 3;
+var DatafileHttpError = class extends Error {
+  constructor(status, statusText) {
+    super(`Failed to fetch data: ${statusText}`);
+    this.status = status;
+  }
+  status;
+  get retryable() {
+    return this.status === 408 || this.status === 429 || this.status >= 500;
+  }
+};
 async function fetchDatafile(options) {
-  const token = await options.auth.resolveToken();
+  options.signal?.throwIfAborted();
+  const maxAttempts = options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+  if (!Number.isInteger(maxAttempts) || maxAttempts < 1) {
+    throw new Error("maxAttempts must be a positive integer");
+  }
   const controller = new AbortController();
+  const { signal } = controller;
+  let rejectAbort;
+  const aborted = new Promise((_, reject) => {
+    rejectAbort = reject;
+  });
+  const onAbort = () => rejectAbort(signal.reason);
+  signal.addEventListener("abort", onAbort, { once: true });
+  const onExternalAbort = () => controller.abort(options.signal?.reason);
+  options.signal?.addEventListener("abort", onExternalAbort, { once: true });
   const timeoutId = setTimeout(
-    () => controller.abort(),
+    () => controller.abort(
+      new Error("@vercel/flags-core: Datafile fetch deadline exceeded")
+    ),
     DEFAULT_FETCH_TIMEOUT_MS
   );
-  const onExternalAbort = () => controller.abort();
-  if (options.signal) {
-    if (options.signal.aborted) {
-      clearTimeout(timeoutId);
-      throw new Error("Fetch aborted");
-    }
-    options.signal.addEventListener("abort", onExternalAbort, { once: true });
-  }
-  try {
+  let delay;
+  const fetchAttempt = async () => {
+    const token = await options.auth.resolveToken();
+    signal.throwIfAborted();
     const res = await options.fetch(`${options.host}/v1/datafile`, {
       headers: {
         Authorization: `Bearer ${token}`,
         "User-Agent": `VercelFlagsCore/${version}`,
         ...process.env.VERCEL_ENV ? { "X-Vercel-Env": process.env.VERCEL_ENV } : null
       },
-      signal: controller.signal
+      signal
     });
-    clearTimeout(timeoutId);
-    options.signal?.removeEventListener("abort", onExternalAbort);
+    signal.throwIfAborted();
     if (!res.ok) {
-      throw new Error(`Failed to fetch data: ${res.statusText}`);
+      void res.body?.cancel().catch(() => {
+      });
+      throw new DatafileHttpError(res.status, res.statusText);
     }
-    return res.json();
-  } catch (error) {
+    const data = await res.json();
+    signal.throwIfAborted();
+    return data;
+  };
+  try {
+    for (let attempt = 0; ; attempt++) {
+      if (attempt > 0) {
+        await Promise.race([
+          new Promise((resolve) => {
+            delay = setTimeout(resolve, 100 * 2 ** (attempt - 1));
+          }),
+          aborted
+        ]);
+      }
+      signal.throwIfAborted();
+      try {
+        return await Promise.race([fetchAttempt(), aborted]);
+      } catch (error) {
+        signal.throwIfAborted();
+        if (attempt === maxAttempts - 1 || error instanceof DatafileHttpError && !error.retryable) {
+          throw error instanceof Error ? error : new Error("Unknown fetch error");
+        }
+      }
+    }
+  } finally {
     clearTimeout(timeoutId);
+    clearTimeout(delay);
+    signal.removeEventListener("abort", onAbort);
     options.signal?.removeEventListener("abort", onExternalAbort);
-    throw error instanceof Error ? error : new Error("Unknown fetch error");
   }
 }
 
@@ -1638,13 +1684,16 @@ var PollingSource = class extends TypedEmitter {
    */
   async poll() {
     if (this.abortController?.signal.aborted) return;
+    this.abortController ??= new AbortController();
+    const controller = this.abortController;
     try {
       const data = await fetchDatafile({
         ...this.config,
-        signal: this.abortController?.signal
+        signal: controller.signal
       });
       this.emit("data", data);
     } catch (error) {
+      controller.signal.throwIfAborted();
       const err = error instanceof Error ? error : new Error("Unknown poll error");
       this.emit("error", err);
     }
@@ -1656,9 +1705,9 @@ var PollingSource = class extends TypedEmitter {
    */
   startInterval() {
     if (this.intervalId) return;
-    this.abortController = new AbortController();
     this.intervalId = setInterval(
-      () => void this.poll(),
+      () => void this.poll().catch(() => {
+      }),
       this.config.polling.intervalMs
     );
   }
@@ -2759,4 +2808,4 @@ export {
   resetDefaultFlagsClient,
   createClient
 };
-//# sourceMappingURL=chunk-DAWMMLXD.js.map
+//# sourceMappingURL=chunk-ZUA6TEG3.js.map