@haystackeditor/cli 0.15.27 → 0.15.28

package/dist/assets/telemetry/browser-runtime.js

@@ -18,6 +18,10 @@ var __haystackWebAtlasModuleApi = (function installHaystackWebAtlas(host) {
   } catch (_) { return null; }
 
   var MAX_EVENTS = 128;
+  var MAX_RUNTIME_SITE_MAPPINGS = 256;
+  var MAX_ACTION_SEGMENTS_PER_PAGE = 256;
+  var MAX_ACTION_SEGMENT_BYTES_PER_PAGE = 1024 * 1024;
+  var MAX_FALLBACK_DELIVERIES_IN_FLIGHT = 2;
   var TRACE_HEADER = 'x-haystack-trace-id';
   var ACTION_HEADER = 'x-haystack-action-id';
   var COHORT_HEADER = 'x-haystack-cohort';
@@ -25,7 +29,13 @@ var __haystackWebAtlasModuleApi = (function installHaystackWebAtlas(host) {
   var REQUEST_SITE_HEADER = 'x-haystack-request-site-id';
   var nativeFunctionToString = Function.prototype.toString;
   var nativeGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+  var nativeGetOwnPropertyDescriptors = Object.getOwnPropertyDescriptors;
   var nativeGetPrototypeOf = Object.getPrototypeOf;
+  var nativeObjectCreate = Object.create;
+  var nativeDefineProperties = Object.defineProperties;
+  var nativeDefineProperty = Object.defineProperty;
+  var nativeObjectPrototype = Object.prototype;
+  var nativeObjectKeys = Object.keys;
   var nativeHasOwnProperty = Object.prototype.hasOwnProperty;
   var nativeReflectApply = Reflect.apply.bind(Reflect);
   var nativeReflectConstruct = Reflect.construct.bind(Reflect);
@@ -78,7 +88,13 @@ var __haystackWebAtlasModuleApi = (function installHaystackWebAtlas(host) {
   var pagehideInstalled = false;
   var nativeArrayIsArray = Array.isArray;
   var active = null;
+  var directProbeContext = null;
+  var overlapQuarantine = false;
   var recorderDisabled = false;
+  var actionSegmentsAttempted = 0;
+  var actionSegmentBytesAttempted = 0;
+  var fallbackDeliveriesInFlight = 0;
+  var fallbackDeliveryUnavailable = false;
   var runtimeActions = Object.create(null);
   var runtimeSites = Object.create(null);
   var assignedCohort = null;
@@ -101,6 +117,34 @@ var __haystackWebAtlasModuleApi = (function installHaystackWebAtlas(host) {
     // in successful records; recorder failures must never affect the app.
   }
 
+  function omit(context) {
+    if (!context || context.saturated) return;
+    context.omittedEvents++;
+    // Omission accounting is telemetry work too. Once its bounded budget is
+    // exhausted, all later probes in this action become lossy pass-throughs.
+    if (context.omittedEvents >= MAX_EVENTS) context.saturated = true;
+  }
+
+  function saturate(context) {
+    if (!context || context.saturated) return;
+    omit(context);
+    context.saturated = true;
+  }
+
+  function admitProbe(context) {
+    if (!context || context.saturated) return false;
+    if (!overlapQuarantine || directProbeContext === context) return true;
+    // JavaScript does not expose a portable async-context owner. After one
+    // genuine overlap, a token-only late probe could belong to either root.
+    // Keep exact action boundaries and captured continuations, but disclose at
+    // most one omitted ambiguous probe per later action instead of guessing.
+    if (!context.quarantineProbeOmitted) {
+      context.quarantineProbeOmitted = true;
+      omit(context);
+    }
+    return false;
+  }
+
   function ownDataValue(name) {
     return safeHostData(name);
   }
@@ -176,6 +220,21 @@ var __haystackWebAtlasModuleApi = (function installHaystackWebAtlas(host) {
     return null;
   }
 
+  function safeContractPrototypeMethod(receiver, name) {
+    try {
+      var cursor = nativeGetPrototypeOf(receiver);
+      for (var depth = 0; cursor && depth < 12; depth++) {
+        var descriptor = nativeGetOwnPropertyDescriptor(cursor, name);
+        if (descriptor) {
+          return nativeReflectApply(nativeHasOwnProperty, descriptor, ['value']) &&
+            typeof descriptor.value === 'function' ? descriptor.value : null;
+        }
+        cursor = nativeGetPrototypeOf(cursor);
+      }
+    } catch (_) { return null; }
+    return null;
+  }
+
   function acquirePlatformCapabilities() {
     if (platformCapabilitiesAcquired) return;
     platformCapabilitiesAcquired = true;
@@ -352,7 +411,8 @@ var __haystackWebAtlasModuleApi = (function installHaystackWebAtlas(host) {
         var conditionPairs = config[5];
         var fetchPairs = config[6];
         if (!nativeArrayIsArray(conditionPairs) || !nativeArrayIsArray(fetchPairs) ||
-            conditionPairs.length > MAX_EVENTS || fetchPairs.length > MAX_EVENTS) return false;
+            conditionPairs.length > MAX_RUNTIME_SITE_MAPPINGS ||
+            fetchPairs.length > MAX_RUNTIME_SITE_MAPPINGS) return false;
         for (var compactConditionIndex = 0; compactConditionIndex < conditionPairs.length; compactConditionIndex++) {
           var conditionPair = conditionPairs[compactConditionIndex];
           if (!nativeArrayIsArray(conditionPair) || conditionPair.length !== 2 ||
@@ -364,6 +424,7 @@ var __haystackWebAtlasModuleApi = (function installHaystackWebAtlas(host) {
           var fetchPair = fetchPairs[compactFetchIndex];
           if (!nativeArrayIsArray(fetchPair) || fetchPair.length !== 3 ||
               typeof fetchPair[0] !== 'string' || !/^f-[0-9a-f]{16}$/.test(fetchPair[0]) ||
+              (fetchPair[2] !== null && (typeof fetchPair[2] !== 'string' || !/^site-[0-9a-f]{24}$/.test(fetchPair[2]))) ||
               compactFetches[fetchPair[0]] !== undefined) return false;
           compactFetches[fetchPair[0]] = { requestSiteId: fetchPair[1], responseSiteId: fetchPair[2] };
         }
@@ -393,7 +454,7 @@ var __haystackWebAtlasModuleApi = (function installHaystackWebAtlas(host) {
         var fetchSites = config.fetchSites[fetchTokens[fetchIndex]];
         if (!fetchSites) return false;
         pendingSites.push([fetchSites.requestSiteId, 'request']);
-        pendingSites.push([fetchSites.responseSiteId, 'response']);
+        if (fetchSites.responseSiteId !== null) pendingSites.push([fetchSites.responseSiteId, 'response']);
       }
       var preparedSites = [];
       var preparedIds = Object.create(null);
@@ -433,16 +494,25 @@ var __haystackWebAtlasModuleApi = (function installHaystackWebAtlas(host) {
 
   function emit(siteId, kind, outcome, parentEventId) {
     try {
-      if (!active) return null;
+      if (!active || active.saturated) return null;
+      if (kind === 'condition' && active.conditionEvents >= active.conditionEventLimit) {
+        if (!active.conditionBudgetOmitted) {
+          active.conditionBudgetOmitted = true;
+          omit(active);
+        }
+        return null;
+      }
       var site = siteFor(siteId);
       if (!site || site.actionId !== active.actionId || site.surface !== 'browser' ||
           site.kind !== kind || !Array.isArray(site.allowedOutcomes) ||
           site.allowedOutcomes.indexOf(outcome) === -1 || !trustedOutcome(outcome)) {
-        active.omittedEvents++;
+        omit(active);
         return null;
       }
       if (active.events.length >= MAX_EVENTS) {
-        active.omittedEvents++;
+        // The event buffer is the observation budget. Do not repeatedly
+        // validate and count the unobserved tail of a hot customer loop.
+        saturate(active);
         return null;
       }
       var eventId = 'browser-' + active.traceId + '-' + String(active.events.length + 1).padStart(4, '0');
@@ -455,6 +525,7 @@ var __haystackWebAtlasModuleApi = (function installHaystackWebAtlas(host) {
         ordinal: active.events.length + 1,
       };
       active.events.push(event);
+      if (kind === 'condition') active.conditionEvents++;
       active.parentEventId = eventId;
       return eventId;
     } catch (_) {
@@ -504,11 +575,13 @@ var __haystackWebAtlasModuleApi = (function installHaystackWebAtlas(host) {
     if (!applicationFetch) throw new TypeError('fetch is not available');
     var context = active;
     if (!context) return invokeApplicationFetch(applicationFetch, input, init, hasInit);
+    if (!admitProbe(context)) return invokeApplicationFetch(applicationFetch, input, init, hasInit);
+    if (context.saturated) return invokeApplicationFetch(applicationFetch, input, init, hasInit);
     // Adding correlation headers necessarily converts a string into Request.
     // That is invisible to the platform fetch but observable to an application
     // wrapper. Never alter a later-installed/customer fetch wrapper.
     if (!platformFetchCorrelationAllowed() || !initialFetchLooksNative || fetchImplementation !== nativeFetchFunction) {
-      context.omittedEvents++;
+      omit(context);
       return invokeApplicationFetch(applicationFetch, input, init, hasInit);
     }
     var fetchInput = input;
@@ -523,18 +596,18 @@ var __haystackWebAtlasModuleApi = (function installHaystackWebAtlas(host) {
       // and disclose the missing continuation instead. Objects include Request
       // and URL here: avoiding `instanceof` also avoids Proxy prototype traps.
       if (typeof input !== 'string') {
-        context.omittedEvents++;
+        omit(context);
         return invokeApplicationFetch(applicationFetch, input, init, hasInit);
       }
       if (!nativeLocationHref || !nativeLocationOrigin || !nativeUrlConstructor ||
           !nativeUrlCanParse || !nativeRequestConstructor || !nativeHeadersConstructor || !nativeUrlHrefGetter ||
           !nativeRequestHeadersGetter || !nativeHeadersHas || !nativeHeadersGet || !nativeHeadersSet ||
           !nativeResponseHeadersGetter || !nativeResponseOkGetter || !nativePromiseReject) {
-        context.omittedEvents++;
+        omit(context);
         return invokeApplicationFetch(applicationFetch, input, init, hasInit);
       }
       if (!nativeReflectApply(nativeUrlCanParse, nativeUrlConstructor, [input, nativeLocationHref])) {
-        context.omittedEvents++;
+        omit(context);
         return invokeApplicationFetch(applicationFetch, input, init, hasInit);
       }
       var urlValue = nativeReflectConstruct(nativeUrlConstructor, [input, nativeLocationHref]);
@@ -559,7 +632,7 @@ var __haystackWebAtlasModuleApi = (function installHaystackWebAtlas(host) {
           // Existing application/distributed-tracing headers win. The already
           // constructed native Request preserves their exact platform
           // semantics without evaluating the original init twice.
-          context.omittedEvents++;
+          omit(context);
           fetchInput = request;
           fetchInit = undefined;
         } else {
@@ -583,7 +656,7 @@ var __haystackWebAtlasModuleApi = (function installHaystackWebAtlas(host) {
       }
     } catch (error) {
       failOpen();
-      context.omittedEvents++;
+      omit(context);
       if (normalizedRequest) {
         // Request conversion already completed. A later telemetry-only failure
         // must still perform the application fetch exactly once.
@@ -601,7 +674,7 @@ var __haystackWebAtlasModuleApi = (function installHaystackWebAtlas(host) {
     if (!requestParent) return result;
     if (!nativePromiseThen || result === null ||
         (typeof result !== 'object' && typeof result !== 'function')) {
-      context.omittedEvents++;
+      omit(context);
       scheduleFinish(context);
       return result;
     }
@@ -610,6 +683,10 @@ var __haystackWebAtlasModuleApi = (function installHaystackWebAtlas(host) {
       nativeReflectApply(nativePromiseThen, result, [function (response) {
         context.pendingFetches--;
         if (context === active) {
+          if (context.saturated) {
+            scheduleFinish(context);
+            return;
+          }
           try {
             var responseHeaders = nativeReflectApply(nativeResponseHeadersGetter, response, []);
             var serverParent = nativeReflectApply(nativeHeadersHas, responseHeaders, [PARENT_EVENT_HEADER])
@@ -617,7 +694,7 @@ var __haystackWebAtlasModuleApi = (function installHaystackWebAtlas(host) {
               : null;
             var safeServerParent = safeNodeResponseId(context.traceId, requestParent, serverParent);
             if (serverParent !== null && safeServerParent === null) {
-              context.omittedEvents++;
+              omit(context);
               serverParent = null;
             } else {
               serverParent = safeServerParent;
@@ -629,7 +706,7 @@ var __haystackWebAtlasModuleApi = (function installHaystackWebAtlas(host) {
               serverParent || requestParent,
             );
           } catch (_) {
-            context.omittedEvents++;
+            omit(context);
             failOpen();
           }
           scheduleFinish(context);
@@ -647,7 +724,7 @@ var __haystackWebAtlasModuleApi = (function installHaystackWebAtlas(host) {
       }]);
     } catch (_) {
       context.pendingFetches--;
-      context.omittedEvents++;
+      omit(context);
       scheduleFinish(context);
       failOpen();
     }
@@ -656,45 +733,518 @@ var __haystackWebAtlasModuleApi = (function installHaystackWebAtlas(host) {
     return result;
   }
 
+  function axiosOmission(state) {
+    if (!state.omissionRecorded) {
+      state.omissionRecorded = true;
+      omit(state.context);
+    }
+  }
+
+  function cloneAxiosConfig(config) {
+    if (config === undefined || config === null) return {};
+    if (typeof config !== 'object' || nativeArrayIsArray(config)) return null;
+    if (nativeGetPrototypeOf(config) !== nativeObjectPrototype) return null;
+    var clone = {};
+    var keys = nativeObjectKeys(config);
+    for (var index = 0; index < keys.length; index++) {
+      var key = keys[index];
+      var descriptor = nativeGetOwnPropertyDescriptor(config, key);
+      if (!descriptor || !nativeReflectApply(nativeHasOwnProperty, descriptor, ['value'])) return null;
+      Object.defineProperty(clone, key, {
+        configurable: true, enumerable: true, writable: true, value: descriptor.value,
+      });
+    }
+    return clone;
+  }
+
+  function axiosTransformList(owner, config) {
+    var descriptor = nativeGetOwnPropertyDescriptor(config, 'transformRequest');
+    var configured;
+    if (descriptor) {
+      if (!nativeReflectApply(nativeHasOwnProperty, descriptor, ['value'])) return null;
+      configured = descriptor.value;
+    } else {
+      var defaultsDescriptor = owner && nativeGetOwnPropertyDescriptor(owner, 'defaults');
+      if (!defaultsDescriptor || !nativeReflectApply(nativeHasOwnProperty, defaultsDescriptor, ['value']) ||
+          !defaultsDescriptor.value) return null;
+      var transformDescriptor = nativeGetOwnPropertyDescriptor(defaultsDescriptor.value, 'transformRequest');
+      if (!transformDescriptor || !nativeReflectApply(nativeHasOwnProperty, transformDescriptor, ['value'])) return null;
+      configured = transformDescriptor.value;
+    }
+    if (typeof configured === 'function') return [configured];
+    if (nativeArrayIsArray(configured)) {
+      var copy = [];
+      for (var index = 0; index < configured.length; index++) {
+        if (typeof configured[index] !== 'function') return null;
+        copy[index] = configured[index];
+      }
+      return copy;
+    }
+    if (configured === undefined || configured === null) return [];
+    return null;
+  }
+
+  function axiosResponseHeader(headers, name) {
+    if (!headers) return null;
+    var get = headers.get;
+    if (typeof get !== 'function') return null;
+    var value = nativeReflectApply(get, headers, [name]);
+    return typeof value === 'string' ? value : null;
+  }
+
+  function observeAxiosResult(result, state) {
+    if (!nativePromiseThen || result === null ||
+        (typeof result !== 'object' && typeof result !== 'function')) {
+      axiosOmission(state);
+      scheduleFinish(state.context);
+      return result;
+    }
+    state.context.pendingFetches++;
+    try {
+      nativeReflectApply(nativePromiseThen, result, [function (response) {
+        state.context.pendingFetches--;
+        if (state.context === active) {
+          if (state.context.saturated) {
+            scheduleFinish(state.context);
+            return;
+          }
+          var requestParent = state.requestParents.length > 0
+            ? state.requestParents[state.requestParents.length - 1]
+            : null;
+          if (!requestParent) {
+            axiosOmission(state);
+          } else {
+            try {
+              var serverParentValue = axiosResponseHeader(response && response.headers, PARENT_EVENT_HEADER);
+              var serverParent = safeNodeResponseId(state.context.traceId, requestParent, serverParentValue);
+              if (serverParentValue !== null && serverParent === null) axiosOmission(state);
+              var status = response && response.status;
+              emit(
+                state.sites.responseSiteId,
+                'response',
+                typeof status === 'number' && status >= 200 && status < 300 ? 'success' : 'error',
+                serverParent || requestParent,
+              );
+            } catch (_) { axiosOmission(state); failOpen(); }
+          }
+          scheduleFinish(state.context);
+        }
+      }, function (error) {
+        state.context.pendingFetches--;
+        if (state.context === active) {
+          var requestParent = state.requestParents.length > 0
+            ? state.requestParents[state.requestParents.length - 1]
+            : null;
+          if (!requestParent) {
+            axiosOmission(state);
+          } else {
+            try {
+              var response = error && error.response;
+              var serverParentValue = response
+                ? axiosResponseHeader(response.headers, PARENT_EVENT_HEADER)
+                : null;
+              var serverParent = response
+                ? safeNodeResponseId(state.context.traceId, requestParent, serverParentValue)
+                : null;
+              if (serverParentValue !== null && serverParent === null) axiosOmission(state);
+              emit(
+                state.sites.responseSiteId,
+                'response',
+                response ? 'error' : 'network:error',
+                serverParent || requestParent,
+              );
+            } catch (_) { axiosOmission(state); failOpen(); }
+          }
+          scheduleFinish(state.context);
+        }
+        throw error;
+      }]);
+    } catch (_) {
+      state.context.pendingFetches--;
+      axiosOmission(state);
+      scheduleFinish(state.context);
+      failOpen();
+    }
+    return result;
+  }
+
+  function axiosAt(token, owner, callable, receiver, configIndex, safeConfig, applicationArguments) {
+    if (!nativeArrayIsArray(applicationArguments) || typeof callable !== 'function') {
+      return nativeReflectApply(callable, receiver, applicationArguments);
+    }
+    var context = active;
+    if (context && context.saturated) return nativeReflectApply(callable, receiver, applicationArguments);
+    if (context && !admitProbe(context)) return nativeReflectApply(callable, receiver, applicationArguments);
+    var sites = context && context.runtimeConfig && context.runtimeConfig.fetchSites[token];
+    if (!context || !sites) return nativeReflectApply(callable, receiver, applicationArguments);
+    if (safeConfig !== true || !Number.isInteger(configIndex) || configIndex < 0 || configIndex > 8 ||
+        !platformFetchCorrelationAllowed()) {
+      omit(context);
+      return nativeReflectApply(callable, receiver, applicationArguments);
+    }
+    var state = { context: context, sites: sites, requestParents: [], omissionRecorded: false };
+    var args = [];
+    var config;
+    try {
+      for (var argumentIndex = 0; argumentIndex < applicationArguments.length; argumentIndex++) {
+        args[argumentIndex] = applicationArguments[argumentIndex];
+      }
+      config = cloneAxiosConfig(args[configIndex]);
+      var transforms = config && axiosTransformList(owner, config);
+      if (!config || !transforms) {
+        axiosOmission(state);
+        return nativeReflectApply(callable, receiver, applicationArguments);
+      }
+      transforms.push(function haystackAxiosRequestTransform(data, headers) {
+        if (context !== active) return data;
+        if (context.saturated) return data;
+        try {
+          var requestConfig = this;
+          var requestUrl = requestConfig && requestConfig.url;
+          var baseUrl = requestConfig && requestConfig.baseURL;
+          if (typeof requestUrl !== 'string' || (baseUrl !== undefined && baseUrl !== null && typeof baseUrl !== 'string') ||
+              !nativeLocationHref || !nativeLocationOrigin || !nativeUrlConstructor || !nativeUrlHrefGetter ||
+              !headers || typeof headers.has !== 'function' || typeof headers.set !== 'function') {
+            axiosOmission(state);
+            return data;
+          }
+          var resolvedBase = baseUrl
+            ? nativeReflectApply(nativeUrlHrefGetter, nativeReflectConstruct(nativeUrlConstructor, [baseUrl, nativeLocationHref]), [])
+            : nativeLocationHref;
+          var resolvedUrl = nativeReflectApply(
+            nativeUrlHrefGetter,
+            nativeReflectConstruct(nativeUrlConstructor, [requestUrl, resolvedBase]),
+            [],
+          );
+          if (resolvedUrl !== nativeLocationOrigin && resolvedUrl.indexOf(nativeLocationOrigin + '/') !== 0) {
+            axiosOmission(state);
+            return data;
+          }
+          var reservedHeaders = [TRACE_HEADER, ACTION_HEADER, COHORT_HEADER, PARENT_EVENT_HEADER, REQUEST_SITE_HEADER, 'traceparent'];
+          for (var headerIndex = 0; headerIndex < reservedHeaders.length; headerIndex++) {
+            if (nativeReflectApply(headers.has, headers, [reservedHeaders[headerIndex]])) {
+              axiosOmission(state);
+              return data;
+            }
+          }
+          var requestParent = emit(sites.requestSiteId, 'request', 'sent', context.inputEventId || undefined);
+          if (!requestParent) {
+            axiosOmission(state);
+            return data;
+          }
+          nativeReflectApply(headers.set, headers, [TRACE_HEADER, context.traceId]);
+          nativeReflectApply(headers.set, headers, [ACTION_HEADER, context.actionId]);
+          nativeReflectApply(headers.set, headers, [COHORT_HEADER, '' + context.cohortIndex]);
+          nativeReflectApply(headers.set, headers, [PARENT_EVENT_HEADER, requestParent]);
+          nativeReflectApply(headers.set, headers, [REQUEST_SITE_HEADER, sites.requestSiteId]);
+          nativeReflectApply(headers.set, headers, ['traceparent', traceparent(context.traceId)]);
+          state.requestParents.push(requestParent);
+        } catch (_) { axiosOmission(state); failOpen(); }
+        return data;
+      });
+      config.transformRequest = transforms;
+      while (args.length < configIndex) args.push(undefined);
+      args[configIndex] = config;
+    } catch (_) {
+      axiosOmission(state);
+      return nativeReflectApply(callable, receiver, applicationArguments);
+    }
+    var result = nativeReflectApply(callable, receiver, args);
+    return observeAxiosResult(result, state);
+  }
+
+  function oazapftsAt(token, owner, callable, safeOptions, applicationArguments) {
+    if (!nativeArrayIsArray(applicationArguments) || typeof callable !== 'function') {
+      return nativeReflectApply(callable, owner, applicationArguments);
+    }
+    var context = active;
+    if (context && context.saturated) return nativeReflectApply(callable, owner, applicationArguments);
+    if (context && !admitProbe(context)) return nativeReflectApply(callable, owner, applicationArguments);
+    var sites = context && context.runtimeConfig && context.runtimeConfig.fetchSites[token];
+    if (!context || !sites) return nativeReflectApply(callable, owner, applicationArguments);
+    if (safeOptions !== true || !platformFetchCorrelationAllowed() || !nativeFetchFunction) {
+      omit(context);
+      return nativeReflectApply(callable, owner, applicationArguments);
+    }
+    var args = [];
+    try {
+      for (var argumentIndex = 0; argumentIndex < applicationArguments.length; argumentIndex++) {
+        args[argumentIndex] = applicationArguments[argumentIndex];
+      }
+      var options = cloneAxiosConfig(args[1]);
+      if (!options || nativeGetOwnPropertyDescriptor(options, 'fetch')) {
+        omit(context);
+        return nativeReflectApply(callable, owner, applicationArguments);
+      }
+      Object.defineProperty(options, 'fetch', {
+        configurable: true,
+        enumerable: true,
+        writable: true,
+        value: function haystackOazapftsFetch(input, init) {
+          if (arguments.length > 2) {
+            omit(context);
+            return nativeReflectApply(nativeFetchFunction, undefined, arguments);
+          }
+          if (context !== active) {
+            return invokeApplicationFetch(nativeFetchFunction, input, init, arguments.length >= 2);
+          }
+          return correlatedFetch(
+            nativeFetchFunction,
+            input,
+            init,
+            sites,
+            arguments.length >= 2,
+          );
+        },
+      });
+      while (args.length < 1) args.push(undefined);
+      args[1] = options;
+    } catch (_) {
+      omit(context);
+      return nativeReflectApply(callable, owner, applicationArguments);
+    }
+    return nativeReflectApply(callable, owner, args);
+  }
+
   function fetchAt(token, fetchImplementation, input, init) {
     if (arguments.length > 4) {
       var passthroughArguments = [];
       for (var argumentIndex = 2; argumentIndex < arguments.length; argumentIndex++) {
         passthroughArguments[argumentIndex - 2] = arguments[argumentIndex];
       }
-      if (active) active.omittedEvents++;
+      if (active) omit(active);
       return nativeReflectApply(fetchImplementation, undefined, passthroughArguments);
     }
     var hasInit = arguments.length >= 4;
     var context = active;
+    if (context && context.saturated) {
+      return invokeApplicationFetch(fetchImplementation, input, init, hasInit);
+    }
+    if (context && !admitProbe(context)) {
+      return invokeApplicationFetch(fetchImplementation, input, init, hasInit);
+    }
     var sites = context && context.runtimeConfig && context.runtimeConfig.fetchSites[token];
     if (context && !sites) return invokeApplicationFetch(fetchImplementation, input, init, hasInit);
     return correlatedFetch(fetchImplementation, input, init, sites, hasInit);
   }
 
+  function mergeAngularHttpContractOptions(options, headerPairs) {
+    try {
+      if (!options || typeof options !== 'object' || nativeGetPrototypeOf(options) !== nativeObjectPrototype ||
+          typeof nativeGetOwnPropertyDescriptors !== 'function' || typeof nativeObjectCreate !== 'function' ||
+          typeof nativeDefineProperties !== 'function' || typeof nativeDefineProperty !== 'function') return null;
+      var descriptors = nativeGetOwnPropertyDescriptors(options);
+      var headersDescriptor = descriptors && descriptors.headers;
+      if (!headersDescriptor || !nativeReflectApply(nativeHasOwnProperty, headersDescriptor, ['value']) ||
+          !headersDescriptor.value || typeof headersDescriptor.value !== 'object') return null;
+      var headers = headersDescriptor.value;
+      var has = safeContractPrototypeMethod(headers, 'has');
+      var set = safeContractPrototypeMethod(headers, 'set');
+      if (!has || !set) return null;
+      for (var checkIndex = 0; checkIndex < headerPairs.length; checkIndex++) {
+        var present = nativeReflectApply(has, headers, [headerPairs[checkIndex][0]]);
+        if (present !== false) return null;
+      }
+      var nextHeaders = headers;
+      var headersPrototype = nativeGetPrototypeOf(headers);
+      for (var setIndex = 0; setIndex < headerPairs.length; setIndex++) {
+        nextHeaders = nativeReflectApply(set, nextHeaders, headerPairs[setIndex]);
+        if (!nextHeaders || typeof nextHeaders !== 'object' ||
+            nativeGetPrototypeOf(nextHeaders) !== headersPrototype) return null;
+      }
+      var clone = nativeObjectCreate(nativeObjectPrototype);
+      nativeDefineProperties(clone, descriptors);
+      nativeDefineProperty(clone, 'headers', {
+        configurable: headersDescriptor.configurable,
+        enumerable: headersDescriptor.enumerable,
+        writable: headersDescriptor.writable,
+        value: nextHeaders,
+      });
+      return clone;
+    } catch (_) { return null; }
+  }
+
+  // Angular HttpClient returns a cold Observable. Observing that Observable
+  // would either subscribe twice or replace the application value. Instead,
+  // the compiler-authenticated call site adds the exact correlation headers
+  // before Angular constructs the request. Existing options are admitted only
+  // for a build-declared source/export contract and are copied without reading
+  // application fields. The correlated Node continuation is the terminal HTTP
+  // outcome for this transport, so no browser response is fabricated.
+  function angularHttpAt(token, callable, receiver, method, applicationArguments, optionsAdapter) {
+    if (!nativeArrayIsArray(applicationArguments) || typeof callable !== 'function') {
+      return nativeReflectApply(callable, receiver, applicationArguments);
+    }
+    var context = active;
+    if (context && context.saturated) return nativeReflectApply(callable, receiver, applicationArguments);
+    if (context && !admitProbe(context)) return nativeReflectApply(callable, receiver, applicationArguments);
+    var sites = context && context.runtimeConfig && context.runtimeConfig.fetchSites[token];
+    if (!context || !sites) return nativeReflectApply(callable, receiver, applicationArguments);
+    var optionsIndex = method === 'delete' || method === 'get' || method === 'head' || method === 'options'
+      ? 1
+      : method === 'patch' || method === 'post' || method === 'put'
+        ? 2
+        : -1;
+    var hasOptions = applicationArguments.length > optionsIndex;
+    if (optionsIndex < 0 || !platformFetchCorrelationAllowed() ||
+        (hasOptions && optionsAdapter !== 'angular-http-headers-set-v1') ||
+        (!hasOptions && optionsAdapter !== null) || applicationArguments.length > optionsIndex + 1 ||
+        typeof applicationArguments[0] !== 'string' ||
+        !nativeLocationHref || !nativeLocationOrigin || !nativeUrlConstructor || !nativeUrlHrefGetter) {
+      omit(context);
+      return nativeReflectApply(callable, receiver, applicationArguments);
+    }
+    var args = [];
+    try {
+      var url = nativeReflectApply(
+        nativeUrlHrefGetter,
+        nativeReflectConstruct(nativeUrlConstructor, [applicationArguments[0], nativeLocationHref]),
+        [],
+      );
+      if (url !== nativeLocationOrigin && url.indexOf(nativeLocationOrigin + '/') !== 0) {
+        omit(context);
+        return nativeReflectApply(callable, receiver, applicationArguments);
+      }
+      if (context.events.length >= MAX_EVENTS) {
+        saturate(context);
+        return nativeReflectApply(callable, receiver, applicationArguments);
+      }
+      var requestParent = 'browser-' + context.traceId + '-' + String(context.events.length + 1).padStart(4, '0');
+      var headerPairs = [
+        ['x-haystack-trace-id', context.traceId],
+        ['x-haystack-action-id', context.actionId],
+        ['x-haystack-cohort', '' + context.cohortIndex],
+        ['x-haystack-parent-event-id', requestParent],
+        ['x-haystack-request-site-id', sites.requestSiteId],
+        ['traceparent', traceparent(context.traceId)],
+      ];
+      for (var index = 0; index < applicationArguments.length; index++) args[index] = applicationArguments[index];
+      if (hasOptions) {
+        var merged = mergeAngularHttpContractOptions(applicationArguments[optionsIndex], headerPairs);
+        if (!merged) {
+          omit(context);
+          return nativeReflectApply(callable, receiver, applicationArguments);
+        }
+        args[optionsIndex] = merged;
+      } else {
+        while (args.length < optionsIndex) args.push(undefined);
+        args[optionsIndex] = { headers: {
+          'x-haystack-trace-id': context.traceId,
+          'x-haystack-action-id': context.actionId,
+          'x-haystack-cohort': '' + context.cohortIndex,
+          'x-haystack-parent-event-id': requestParent,
+          'x-haystack-request-site-id': sites.requestSiteId,
+          'traceparent': traceparent(context.traceId),
+        } };
+      }
+      var emittedParent = emit(sites.requestSiteId, 'request', 'sent', context.inputEventId || undefined);
+      if (emittedParent !== requestParent) {
+        return nativeReflectApply(callable, receiver, applicationArguments);
+      }
+    } catch (_) {
+      omit(context);
+      failOpen();
+      return nativeReflectApply(callable, receiver, applicationArguments);
+    }
+    return nativeReflectApply(callable, receiver, args);
+  }
+
   function deliver(segment) {
     try {
+      if (recorderDisabled) return false;
       var endpoint = configuredEndpoint || ownDataValue('__HAYSTACK_WEB_ATLAS_ENDPOINT__');
-      if (typeof endpoint !== 'string' || endpoint.length === 0) return false;
+      if (typeof endpoint !== 'string' || endpoint.length === 0) {
+        recorderDisabled = true;
+        return false;
+      }
+      if (actionSegmentsAttempted >= MAX_ACTION_SEGMENTS_PER_PAGE ||
+          actionSegmentBytesAttempted >= MAX_ACTION_SEGMENT_BYTES_PER_PAGE) {
+        recorderDisabled = true;
+        return false;
+      }
+      actionSegmentsAttempted++;
       var body = nativeStringify(segment);
-      if (nativeBeacon && nativeBeacon(endpoint, body)) return true;
-      if (nativeFetch && configuredPlatformFetch && initialFetchLooksNative) {
-        var delivery = nativeFetch(endpoint, {
+      if (body.length > MAX_ACTION_SEGMENT_BYTES_PER_PAGE - actionSegmentBytesAttempted) {
+        recorderDisabled = true;
+        return false;
+      }
+      actionSegmentBytesAttempted += body.length;
+      if (actionSegmentsAttempted >= MAX_ACTION_SEGMENTS_PER_PAGE ||
+          actionSegmentBytesAttempted >= MAX_ACTION_SEGMENT_BYTES_PER_PAGE) recorderDisabled = true;
+      if (nativeBeacon) {
+        try { if (nativeBeacon(endpoint, body)) return true; } catch (_) { failOpen(); }
+      }
+      if (!nativeFetch || !configuredPlatformFetch || !initialFetchLooksNative ||
+          !nativePromiseThen || fallbackDeliveryUnavailable ||
+          fallbackDeliveriesInFlight >= MAX_FALLBACK_DELIVERIES_IN_FLIGHT) {
+        // Backpressure is a terminal page-local telemetry condition. Dropping
+        // later evidence is safer than letting a collector outage accumulate
+        // customer-page requests, closures, or serialized trace bodies.
+        recorderDisabled = true;
+        return false;
+      }
+      fallbackDeliveriesInFlight++;
+      var settled = false;
+      var settleFallback = function (failed) {
+        if (settled) return;
+        settled = true;
+        fallbackDeliveriesInFlight--;
+        if (failed) {
+          fallbackDeliveryUnavailable = true;
+          recorderDisabled = true;
+        }
+      };
+      var delivery;
+      try {
+        delivery = nativeFetch(endpoint, {
           method: 'POST',
           body: body,
           keepalive: true,
           headers: { 'Content-Type': 'text/plain' },
         });
-        if (nativePromiseThen && delivery !== null &&
-            (typeof delivery === 'object' || typeof delivery === 'function')) {
-          try { nativeReflectApply(nativePromiseThen, delivery, [function () {}, failOpen]); } catch (_) { failOpen(); }
-        }
-        return true;
+      } catch (_) {
+        settleFallback(true);
+        failOpen();
+        return false;
+      }
+      if (delivery === null ||
+          (typeof delivery !== 'object' && typeof delivery !== 'function')) {
+        settleFallback(true);
+        return false;
+      }
+      try {
+        nativeReflectApply(nativePromiseThen, delivery, [
+          function () { settleFallback(false); },
+          function () { settleFallback(true); },
+        ]);
+      } catch (_) {
+        settleFallback(true);
+        failOpen();
+        return false;
       }
+      return true;
     } catch (_) { failOpen(); }
     return false;
   }
 
+  function conditionEventLimit(sites) {
+    // Action start and input consume two fixed slots. Reserve the output slot
+    // plus one request and (when declared) response for every static fetch
+    // site that can fit inside the hard action ceiling. Conditions use the
+    // remainder and disclose one bounded omission if they exhaust it, rather
+    // than starving higher-value continuations in ordinary actions. If the
+    // static continuations alone exceed the ceiling, conditions receive no
+    // slots and the existing whole-buffer cutoff remains the final bound.
+    var reserved = 1;
+    var tokens = nativeObjectKeys(sites.fetchSites);
+    for (var index = 0; index < tokens.length; index++) {
+      var fetchSites = sites.fetchSites[tokens[index]];
+      reserved += fetchSites && fetchSites.responseSiteId !== null ? 2 : 1;
+    }
+    var available = MAX_EVENTS - 2 - reserved;
+    return available > 0 ? available : 0;
+  }
+
   function beginAction(actionId, sites) {
     try {
       if (active || recorderDisabled) return false;
@@ -716,6 +1266,12 @@ var __haystackWebAtlasModuleApi = (function installHaystackWebAtlas(host) {
         rootReturned: false,
         finishScheduled: false,
         runtimeConfig: sites,
+        conditionOutcomeKeys: Object.create(null),
+        conditionEvents: 0,
+        conditionEventLimit: conditionEventLimit(sites),
+        conditionBudgetOmitted: false,
+        quarantineProbeOmitted: false,
+        saturated: false,
       };
       emit(sites.actionSiteId, 'action-start', 'started', null);
       return true;
@@ -732,13 +1288,24 @@ var __haystackWebAtlasModuleApi = (function installHaystackWebAtlas(host) {
       var sites = runtimeActions[actionId];
       if (!sites) return nativeReflectApply(handler, this, arguments);
       if (active) {
-        // A single global action cannot safely attribute probes from overlapping
-        // async roots. Close the partial trace with an explicit omission and
-        // stop recording this page rather than fabricate either action's path.
-        active.omittedEvents++;
-        recorderDisabled = true;
-        endAction();
-        return nativeReflectApply(handler, this, arguments);
+        // A synchronous root can finish in the same task that starts the next
+        // user action, before its zero-delay cleanup callback has run. It has
+        // no outstanding application work, so close it now and attribute the
+        // new action normally. This is common with input followed immediately
+        // by submit (autofill, keyboard submission, and fast automation).
+        if (active.rootReturned && active.pendingFetches === 0) {
+          endAction();
+        } else {
+          // A single global action cannot safely attribute probes from
+          // overlapping roots. Close the older partial trace with an explicit
+          // omission, then let the exact newer action become the root. Stable
+          // identities still validate captured continuations. Token-only async
+          // probes cannot carry a portable root owner, so direct-probe mode
+          // stays enabled after the first overlap rather than guessing.
+          omit(active);
+          overlapQuarantine = true;
+          endAction();
+        }
       }
       var started = beginAction(actionId, sites);
       if (!started) return nativeReflectApply(handler, this, arguments);
@@ -746,12 +1313,16 @@ var __haystackWebAtlasModuleApi = (function installHaystackWebAtlas(host) {
       var inputEventId = emit(sites.inputSiteId, 'input-shape', shapeOutcome(arguments.length > 0 ? arguments[0] : undefined));
       if (context) context.inputEventId = inputEventId;
       var result;
+      var previousDirectProbeContext = directProbeContext;
+      directProbeContext = context;
       try {
         result = nativeReflectApply(handler, this, arguments);
       } catch (error) {
         if (context) context.rootReturned = true;
-        endAction();
+        if (context === active) endAction();
         throw error;
+      } finally {
+        directProbeContext = previousDirectProbeContext;
       }
 
       // Keep a real Promise-returning action open across awaits. We attach a
@@ -763,7 +1334,9 @@ var __haystackWebAtlasModuleApi = (function installHaystackWebAtlas(host) {
         try {
           nativeReflectApply(nativePromiseThen, result, [function (value) {
             if (context === active) {
-              emit(sites.outputSiteId, 'output-shape', shapeOutcome(value), context.inputEventId || undefined);
+              if (!context.saturated) {
+                emit(sites.outputSiteId, 'output-shape', shapeOutcome(value), context.inputEventId || undefined);
+              }
               context.rootReturned = true;
               scheduleFinish(context);
             }
@@ -780,8 +1353,10 @@ var __haystackWebAtlasModuleApi = (function installHaystackWebAtlas(host) {
       }
       if (!observesPromise) {
         if (context && !nativePromiseThen && result !== null &&
-            (typeof result === 'object' || typeof result === 'function')) context.omittedEvents++;
-        emit(sites.outputSiteId, 'output-shape', shapeOutcome(result), context && context.inputEventId || undefined);
+            (typeof result === 'object' || typeof result === 'function')) omit(context);
+        if (context === active && !context.saturated) {
+          emit(sites.outputSiteId, 'output-shape', shapeOutcome(result), context && context.inputEventId || undefined);
+        }
         if (context) {
           context.rootReturned = true;
           scheduleFinish(context);
@@ -794,12 +1369,34 @@ var __haystackWebAtlasModuleApi = (function installHaystackWebAtlas(host) {
   function conditionAt(token, value) {
     try {
       var context = active;
-      var siteId = context && context.runtimeConfig && context.runtimeConfig.conditionSites[token];
+      if (context && !admitProbe(context)) return value;
+      var siteId = context && !context.saturated && context.runtimeConfig && context.runtimeConfig.conditionSites[token];
       if (siteId) emit(siteId, 'condition', value ? 'boolean:true' : 'boolean:false', context.inputEventId || undefined);
     } catch (_) { failOpen(); }
     return value;
   }
 
+  // Loop and coarse-entry probes can execute many times in one action. Keep
+  // the first observation of each fixed boolean outcome so they cannot crowd
+  // the action's request/response evidence out of the bounded event buffer.
+  function conditionOnceAt(token, value) {
+    try {
+      var context = active;
+      if (context && !admitProbe(context)) return value;
+      var siteId = context && !context.saturated && context.runtimeConfig && context.runtimeConfig.conditionSites[token];
+      if (siteId) {
+        var outcome = value ? 'boolean:true' : 'boolean:false';
+        var key = siteId + '\0' + outcome;
+        var seen = context.conditionOutcomeKeys;
+        if (seen[key] !== true) {
+          seen[key] = true;
+          emit(siteId, 'condition', outcome, context.inputEventId || undefined);
+        }
+      }
+    } catch (_) { failOpen(); }
+    return value;
+  }
+
   function endAction() {
     try {
       if (!active) return null;
@@ -829,19 +1426,30 @@ var __haystackWebAtlasModuleApi = (function installHaystackWebAtlas(host) {
     configure: configure,
     registerAction: registerAction,
     beginAction: beginAction,
-    inputShape: function (siteId, outcome) { emit(siteId, 'input-shape', outcome); },
-    condition: function (siteId, outcome) { emit(siteId, 'condition', outcome); },
+    inputShape: function (siteId, outcome) { if (admitProbe(active)) emit(siteId, 'input-shape', outcome); },
+    condition: function (siteId, outcome) { if (admitProbe(active)) emit(siteId, 'condition', outcome); },
     fetch: correlatedFetch,
     fetchAt: fetchAt,
+    angularHttpAt: angularHttpAt,
+    axiosAt: axiosAt,
+    oazapftsAt: oazapftsAt,
     wrapAction: wrapAction,
     conditionAt: conditionAt,
-    outputShape: function (siteId, outcome) { emit(siteId, 'output-shape', outcome); },
-    uiOutcome: function (siteId, outcome) { emit(siteId, 'ui-outcome', outcome); },
-    error: function (siteId, outcome) { emit(siteId, 'error', outcome); },
+    conditionOnceAt: conditionOnceAt,
+    outputShape: function (siteId, outcome) { if (admitProbe(active)) emit(siteId, 'output-shape', outcome); },
+    uiOutcome: function (siteId, outcome) { if (admitProbe(active)) emit(siteId, 'ui-outcome', outcome); },
+    error: function (siteId, outcome) { if (admitProbe(active)) emit(siteId, 'error', outcome); },
     endAction: endAction,
     status: function () {
       return active
-        ? { active: true, disabled: recorderDisabled, traceId: active.traceId }
+        ? {
+          active: true,
+          disabled: recorderDisabled,
+          saturated: active.saturated,
+          events: active.events.length,
+          omittedEvents: active.omittedEvents,
+          traceId: active.traceId,
+        }
         : { active: false, disabled: recorderDisabled };
     },
   });