@haystackeditor/cli 0.15.26 → 0.15.28

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

@@ -0,0 +1,1469 @@
+/*
+ * Dependency-free browser half of Haystack's experimental web/Node behavior
+ * atlas. A build transform supplies an exact manifest; this runtime records
+ * only manifest-approved enumerated outcomes and propagates a random trace ID
+ * to same-origin requests. It never reads DOM text, request bodies, headers,
+ * cookies, storage values, or arbitrary object properties.
+ */
+var __haystackWebAtlasModuleApi = (function installHaystackWebAtlas(host) {
+  'use strict';
+
+  // Never invoke an application-owned accessor merely by checking our optional
+  // namespace. Only a plain own data property can represent an earlier install.
+  try {
+    var existingDescriptor = Object.getOwnPropertyDescriptor(host, '__haystackWebAtlas');
+    if (existingDescriptor) {
+      return null;
+    }
+  } 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';
+  var PARENT_EVENT_HEADER = 'x-haystack-parent-event-id';
+  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);
+  function safeHostData(name) {
+    try {
+      var descriptor = nativeGetOwnPropertyDescriptor(host, name);
+      return descriptor && nativeReflectApply(nativeHasOwnProperty, descriptor, ['value'])
+        ? descriptor.value
+        : undefined;
+    } catch (_) { return undefined; }
+  }
+  var nativeFetchFunction = safeHostData('fetch');
+  nativeFetchFunction = typeof nativeFetchFunction === 'function' ? nativeFetchFunction : null;
+  var nativeFetch = nativeFetchFunction ? function () {
+    return nativeReflectApply(nativeFetchFunction, host, arguments);
+  } : null;
+  var initialFetchLooksNative = false;
+  try {
+    initialFetchLooksNative = !!nativeFetchFunction &&
+      nativeReflectApply(nativeFunctionToString, nativeFetchFunction, []).indexOf('[native code]') !== -1;
+  } catch (_) { initialFetchLooksNative = false; }
+  var nativeRandomValues = null;
+  var nativeStringify = JSON.stringify.bind(JSON);
+  var nativeBeacon = null;
+  var nativeAddEventListener = null;
+  var hostSetTimeout = safeHostData('setTimeout');
+  var nativeSetTimeout = nativeLooking(hostSetTimeout) ? function () {
+    return nativeReflectApply(hostSetTimeout, host, arguments);
+  } : null;
+  var hostPromise = safeHostData('Promise');
+  var promisePrototype = nativeLooking(hostPromise) ? safeNativeMember(hostPromise, 'prototype') : null;
+  var promiseThen = promisePrototype ? safeNativeMember(promisePrototype, 'then') : null;
+  var nativePromiseThen = nativeLooking(promiseThen) ? promiseThen : null;
+  var promiseReject = nativeLooking(hostPromise) ? safeNativeMember(hostPromise, 'reject') : null;
+  var nativePromiseReject = nativeLooking(promiseReject) ? promiseReject : null;
+  var nativeLocationHref = null;
+  var nativeLocationOrigin = null;
+  var nativeUrlConstructor = null;
+  var nativeUrlCanParse = null;
+  var nativeRequestConstructor = null;
+  var nativeHeadersConstructor = null;
+  var nativeUrlHrefGetter = null;
+  var nativeRequestHeadersGetter = null;
+  var nativeHeadersHas = null;
+  var nativeHeadersGet = null;
+  var nativeHeadersSet = null;
+  var nativeResponseHeadersGetter = null;
+  var nativeResponseOkGetter = null;
+  var platformCapabilitiesAcquired = false;
+  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;
+  var assignedCohortCount = null;
+  var configuredManifest = null;
+  var configuredEndpoint = null;
+  var configuredCohort = null;
+  var configuredPlatformFetch = false;
+  var fixedOutcomes = Object.freeze({
+    started: true, received: true, sent: true, success: true, error: true,
+    'network:error': true, 'boolean:true': true, 'boolean:false': true,
+    'http:2xx': true, 'http:3xx': true, 'http:4xx': true, 'http:5xx': true,
+    'shape:null': true, 'shape:undefined': true, 'shape:boolean': true,
+    'shape:number': true, 'shape:string': true, 'shape:array': true,
+    'shape:object': true, 'shape:uninspectable': true,
+  });
+
+  function failOpen() {
+    // Deliberately silent in the page. Delivery/coverage omissions are carried
+    // 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);
+  }
+
+  function nativeLooking(value) {
+    try {
+      return typeof value === 'function' &&
+        nativeReflectApply(nativeFunctionToString, value, []).indexOf('[native code]') !== -1;
+    } catch (_) { return false; }
+  }
+
+  function safePlatformValue(name) {
+    try {
+      var cursor = host;
+      for (var depth = 0; cursor && depth < 12; depth++) {
+        var descriptor = nativeGetOwnPropertyDescriptor(cursor, name);
+        if (descriptor) {
+          if (nativeReflectApply(nativeHasOwnProperty, descriptor, ['value'])) return descriptor.value;
+          if (!nativeLooking(descriptor.get)) return undefined;
+          return nativeReflectApply(descriptor.get, host, []);
+        }
+        cursor = nativeGetPrototypeOf(cursor);
+      }
+    } catch (_) { return undefined; }
+    return undefined;
+  }
+
+  function safePlatformAccessorValue(name) {
+    try {
+      var cursor = host;
+      for (var depth = 0; cursor && depth < 12; depth++) {
+        var descriptor = nativeGetOwnPropertyDescriptor(cursor, name);
+        if (descriptor) {
+          if (nativeReflectApply(nativeHasOwnProperty, descriptor, ['value']) || !nativeLooking(descriptor.get)) return undefined;
+          return nativeReflectApply(descriptor.get, host, []);
+        }
+        cursor = nativeGetPrototypeOf(cursor);
+      }
+    } catch (_) { return undefined; }
+    return undefined;
+  }
+
+  function safeNativeMember(receiver, name) {
+    try {
+      var cursor = receiver;
+      for (var depth = 0; cursor && depth < 12; depth++) {
+        var descriptor = nativeGetOwnPropertyDescriptor(cursor, name);
+        if (descriptor) {
+          if (nativeReflectApply(nativeHasOwnProperty, descriptor, ['value'])) return descriptor.value;
+          if (!nativeLooking(descriptor.get)) return undefined;
+          return nativeReflectApply(descriptor.get, receiver, []);
+        }
+        cursor = nativeGetPrototypeOf(cursor);
+      }
+    } catch (_) { return undefined; }
+    return undefined;
+  }
+
+  function safeNativeDescriptor(receiver, name) {
+    try {
+      var cursor = receiver;
+      for (var depth = 0; cursor && depth < 12; depth++) {
+        var descriptor = nativeGetOwnPropertyDescriptor(cursor, name);
+        if (descriptor) {
+          if (nativeReflectApply(nativeHasOwnProperty, descriptor, ['value'])) {
+            return nativeLooking(descriptor.value) ? { value: descriptor.value } : null;
+          }
+          return nativeLooking(descriptor.get) ? { get: descriptor.get } : null;
+        }
+        cursor = nativeGetPrototypeOf(cursor);
+      }
+    } catch (_) { return null; }
+    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;
+    var cryptoValue = safePlatformAccessorValue('crypto');
+    var randomValues = cryptoValue && safeNativeMember(cryptoValue, 'getRandomValues');
+    if (nativeLooking(randomValues)) {
+      nativeRandomValues = function (value) { return nativeReflectApply(randomValues, cryptoValue, [value]); };
+    }
+    var navigatorValue = safePlatformAccessorValue('navigator');
+    var beacon = navigatorValue && safeNativeMember(navigatorValue, 'sendBeacon');
+    if (nativeLooking(beacon)) {
+      nativeBeacon = function () { return nativeReflectApply(beacon, navigatorValue, arguments); };
+    }
+    var addEventListener = safePlatformValue('addEventListener');
+    if (nativeLooking(addEventListener)) {
+      nativeAddEventListener = function () { return nativeReflectApply(addEventListener, host, arguments); };
+    }
+    var locationValue = safePlatformAccessorValue('location');
+    try {
+      var href = locationValue && safeNativeMember(locationValue, 'href');
+      var origin = locationValue && safeNativeMember(locationValue, 'origin');
+      nativeLocationHref = typeof href === 'string' ? href : null;
+      nativeLocationOrigin = typeof origin === 'string' ? origin : null;
+    } catch (_) { nativeLocationHref = null; nativeLocationOrigin = null; }
+    var urlConstructor = safePlatformValue('URL');
+    var requestConstructor = safePlatformValue('Request');
+    var headersConstructor = safePlatformValue('Headers');
+    var responseConstructor = safePlatformValue('Response');
+    nativeUrlConstructor = nativeLooking(urlConstructor) ? urlConstructor : null;
+    nativeRequestConstructor = nativeLooking(requestConstructor) ? requestConstructor : null;
+    nativeHeadersConstructor = nativeLooking(headersConstructor) ? headersConstructor : null;
+    var urlPrototype = nativeUrlConstructor && safeNativeMember(nativeUrlConstructor, 'prototype');
+    var urlCanParse = nativeUrlConstructor && safeNativeMember(nativeUrlConstructor, 'canParse');
+    var requestPrototype = nativeRequestConstructor && safeNativeMember(nativeRequestConstructor, 'prototype');
+    var headersPrototype = nativeHeadersConstructor && safeNativeMember(nativeHeadersConstructor, 'prototype');
+    var responsePrototype = nativeLooking(responseConstructor) && safeNativeMember(responseConstructor, 'prototype');
+    var urlHref = urlPrototype && safeNativeDescriptor(urlPrototype, 'href');
+    var requestHeaders = requestPrototype && safeNativeDescriptor(requestPrototype, 'headers');
+    var headersHas = headersPrototype && safeNativeDescriptor(headersPrototype, 'has');
+    var headersGet = headersPrototype && safeNativeDescriptor(headersPrototype, 'get');
+    var headersSet = headersPrototype && safeNativeDescriptor(headersPrototype, 'set');
+    var responseHeaders = responsePrototype && safeNativeDescriptor(responsePrototype, 'headers');
+    var responseOk = responsePrototype && safeNativeDescriptor(responsePrototype, 'ok');
+    nativeUrlHrefGetter = urlHref && urlHref.get || null;
+    nativeUrlCanParse = nativeLooking(urlCanParse) ? urlCanParse : null;
+    nativeRequestHeadersGetter = requestHeaders && requestHeaders.get || null;
+    nativeHeadersHas = headersHas && headersHas.value || null;
+    nativeHeadersGet = headersGet && headersGet.value || null;
+    nativeHeadersSet = headersSet && headersSet.value || null;
+    nativeResponseHeadersGetter = responseHeaders && responseHeaders.get || null;
+    nativeResponseOkGetter = responseOk && responseOk.get || null;
+  }
+
+  function configure(config) {
+    try {
+      if (!config || !config.manifest || config.manifest.schemaVersion !== 'haystack-web-node-atlas-manifest-v1' ||
+          typeof config.endpoint !== 'string' || config.endpoint.length === 0) return false;
+      if (configuredManifest) return configuredManifest === config.manifest;
+      configuredManifest = config.manifest;
+      configuredEndpoint = config.endpoint;
+      configuredCohort = Number.isInteger(config.cohort) ? config.cohort : null;
+      configuredPlatformFetch = config.allowPlatformFetch === true;
+      if (config.allowPlatformCapabilities === true) acquirePlatformCapabilities();
+      if (!pagehideInstalled && nativeAddEventListener && nativeSetTimeout) {
+        nativeAddEventListener('pagehide', function () { try { endAction(); } catch (_) { failOpen(); } });
+        pagehideInstalled = true;
+      }
+      return true;
+    } catch (_) { return false; }
+  }
+
+  function trustedOutcome(value) {
+    if (typeof value !== 'string') return false;
+    if (fixedOutcomes[value] === true) return true;
+    if (value.slice(0, 8) !== 'variant:') return false;
+    var index = Number(value.slice(8));
+    return Number.isInteger(index) && index >= 0 && index < 32 && value === 'variant:' + index;
+  }
+
+  function randomTraceId() {
+    if (!nativeRandomValues) return null;
+    for (var attempt = 0; attempt < 2; attempt++) {
+      var bytes = new Uint8Array(16);
+      nativeRandomValues(bytes);
+      var value = '';
+      for (var index = 0; index < bytes.length; index++) value += bytes[index].toString(16).padStart(2, '0');
+      if (value !== '00000000000000000000000000000000') return value;
+    }
+    return null;
+  }
+
+  function traceparent(traceId) {
+    var spanId = traceId.slice(16);
+    if (spanId === '0000000000000000') spanId = traceId.slice(0, 16);
+    return '00-' + traceId + '-' + spanId + '-01';
+  }
+
+  function safeNodeResponseId(traceId, requestEventId, candidate) {
+    try {
+      var requestOrdinal = Number(requestEventId.slice(-4));
+      var prefix = 'node-' + traceId + '-';
+      if (!Number.isInteger(requestOrdinal) || requestOrdinal < 1 || requestOrdinal > MAX_EVENTS ||
+          typeof candidate !== 'string' || candidate.slice(0, prefix.length) !== prefix) return null;
+      var ordinalText = candidate.slice(prefix.length);
+      if (!/^[0-9]{4,5}$/.test(ordinalText)) return null;
+      var ordinal = Number(ordinalText);
+      var base = requestOrdinal * MAX_EVENTS;
+      return ordinal > base && ordinal <= base + MAX_EVENTS && candidate === prefix + String(ordinal).padStart(4, '0')
+        ? candidate
+        : null;
+    } catch (_) { return null; }
+  }
+
+  function manifest() {
+    var value = configuredManifest || ownDataValue('__HAYSTACK_WEB_ATLAS_MANIFEST__');
+    return value && value.schemaVersion === 'haystack-web-node-atlas-manifest-v1' ? value : null;
+  }
+
+  function platformFetchCorrelationAllowed() {
+    return configuredPlatformFetch || ownDataValue('__HAYSTACK_WEB_ATLAS_ALLOW_PLATFORM_FETCH__') === true;
+  }
+
+  function actionFor(actionId) {
+    if (runtimeActions[actionId]) return runtimeActions[actionId];
+    var value = manifest();
+    if (!value || !Array.isArray(value.actions)) return null;
+    for (var index = 0; index < value.actions.length; index++) {
+      if (value.actions[index] && value.actions[index].actionId === actionId) return value.actions[index];
+    }
+    return null;
+  }
+
+  function siteFor(siteId) {
+    if (runtimeSites[siteId]) return runtimeSites[siteId];
+    var value = manifest();
+    if (!value || !Array.isArray(value.sites)) return null;
+    for (var index = 0; index < value.sites.length; index++) {
+      if (value.sites[index] && value.sites[index].siteId === siteId) return value.sites[index];
+    }
+    return null;
+  }
+
+  function outcomesForKind(kind) {
+    if (kind === 'action-start') return ['started'];
+    if (kind === 'input-shape' || kind === 'output-shape') return [
+      'shape:null', 'shape:undefined', 'shape:boolean', 'shape:number',
+      'shape:string', 'shape:array', 'shape:object', 'shape:uninspectable',
+    ];
+    if (kind === 'condition') return ['boolean:false', 'boolean:true'];
+    if (kind === 'request') return ['sent'];
+    if (kind === 'response') return ['success', 'error', 'network:error'];
+    return [];
+  }
+
+  function runtimeSite(config, siteId, kind) {
+    if (typeof siteId !== 'string' || !/^site-[0-9a-f]{24}$/.test(siteId)) return null;
+    var outcomes = outcomesForKind(kind);
+    if (outcomes.length === 0) return null;
+    return {
+      siteId: siteId,
+      actionId: config.actionId,
+      surface: 'browser',
+      kind: kind,
+      allowedOutcomes: outcomes,
+    };
+  }
+
+  function registerAction(config) {
+    try {
+      if (nativeArrayIsArray(config)) {
+        if (config.length !== 7) return false;
+        var compactConditions = Object.create(null);
+        var compactFetches = Object.create(null);
+        var conditionPairs = config[5];
+        var fetchPairs = config[6];
+        if (!nativeArrayIsArray(conditionPairs) || !nativeArrayIsArray(fetchPairs) ||
+            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 ||
+              typeof conditionPair[0] !== 'string' || !/^c-[0-9a-f]{16}$/.test(conditionPair[0]) ||
+              compactConditions[conditionPair[0]] !== undefined) return false;
+          compactConditions[conditionPair[0]] = conditionPair[1];
+        }
+        for (var compactFetchIndex = 0; compactFetchIndex < fetchPairs.length; compactFetchIndex++) {
+          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] };
+        }
+        config = {
+          actionId: config[0], cohortIndex: config[1], actionSiteId: config[2],
+          inputSiteId: config[3], outputSiteId: config[4],
+          conditionSites: compactConditions, fetchSites: compactFetches,
+        };
+      }
+      if (!config || typeof config.actionId !== 'string' || !/^action-[0-9a-f]{24}$/.test(config.actionId) ||
+          !Number.isInteger(config.cohortIndex) || !config.conditionSites || !config.fetchSites) return false;
+      var configured = manifest();
+      if (!configured || !Number.isInteger(configured.cohortCount) ||
+          config.cohortIndex < 0 || config.cohortIndex >= configured.cohortCount ||
+          (configured.samplingMode === 'session' && config.cohortIndex !== configured.selectedSessionCohort)) return false;
+      if (runtimeActions[config.actionId]) return nativeStringify(runtimeActions[config.actionId]) === nativeStringify(config);
+      var pendingSites = [];
+      pendingSites.push([config.actionSiteId, 'action-start']);
+      pendingSites.push([config.inputSiteId, 'input-shape']);
+      pendingSites.push([config.outputSiteId, 'output-shape']);
+      var conditionTokens = Object.keys(config.conditionSites);
+      for (var conditionIndex = 0; conditionIndex < conditionTokens.length; conditionIndex++) {
+        pendingSites.push([config.conditionSites[conditionTokens[conditionIndex]], 'condition']);
+      }
+      var fetchTokens = Object.keys(config.fetchSites);
+      for (var fetchIndex = 0; fetchIndex < fetchTokens.length; fetchIndex++) {
+        var fetchSites = config.fetchSites[fetchTokens[fetchIndex]];
+        if (!fetchSites) return false;
+        pendingSites.push([fetchSites.requestSiteId, 'request']);
+        if (fetchSites.responseSiteId !== null) pendingSites.push([fetchSites.responseSiteId, 'response']);
+      }
+      var preparedSites = [];
+      var preparedIds = Object.create(null);
+      for (var siteIndex = 0; siteIndex < pendingSites.length; siteIndex++) {
+        var siteId = pendingSites[siteIndex][0];
+        var prepared = runtimeSite(config, siteId, pendingSites[siteIndex][1]);
+        if (!prepared || runtimeSites[siteId] || preparedIds[siteId]) return false;
+        preparedIds[siteId] = true;
+        preparedSites.push(prepared);
+      }
+      for (var commitIndex = 0; commitIndex < preparedSites.length; commitIndex++) {
+        runtimeSites[preparedSites[commitIndex].siteId] = preparedSites[commitIndex];
+      }
+      runtimeActions[config.actionId] = config;
+      return true;
+    } catch (_) {
+      failOpen();
+      return false;
+    }
+  }
+
+  function sessionCohort(cohortCount) {
+    if (assignedCohort !== null && assignedCohortCount === cohortCount) return assignedCohort;
+    var override = configuredCohort === null ? ownDataValue('__HAYSTACK_WEB_ATLAS_COHORT__') : configuredCohort;
+    if (Number.isInteger(override) && override >= 0 && override < cohortCount) {
+      assignedCohort = override;
+      assignedCohortCount = cohortCount;
+      return assignedCohort;
+    }
+    if (!nativeRandomValues) return -1;
+    var value = new Uint32Array(1);
+    nativeRandomValues(value);
+    assignedCohort = value[0] % cohortCount;
+    assignedCohortCount = cohortCount;
+    return assignedCohort;
+  }
+
+  function emit(siteId, kind, outcome, parentEventId) {
+    try {
+      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)) {
+        omit(active);
+        return null;
+      }
+      if (active.events.length >= MAX_EVENTS) {
+        // 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');
+      var event = {
+        eventId: eventId,
+        parentEventId: parentEventId === undefined ? active.parentEventId : parentEventId,
+        siteId: siteId,
+        kind: kind,
+        outcome: outcome,
+        ordinal: active.events.length + 1,
+      };
+      active.events.push(event);
+      if (kind === 'condition') active.conditionEvents++;
+      active.parentEventId = eventId;
+      return eventId;
+    } catch (_) {
+      failOpen();
+      return null;
+    }
+  }
+
+  function shapeOutcome(value) {
+    try {
+      if (value === null) return 'shape:null';
+      if (value === undefined) return 'shape:undefined';
+      // Array.isArray is normally trap-free, but a revoked Proxy throws. Shape
+      // classification is telemetry work and must therefore be total.
+      if (nativeArrayIsArray(value)) return 'shape:array';
+      var kind = typeof value;
+      if (kind === 'boolean' || kind === 'number' || kind === 'string') return 'shape:' + kind;
+      if (kind === 'object') return 'shape:object';
+    } catch (_) { failOpen(); }
+    return 'shape:uninspectable';
+  }
+
+  function invokeApplicationFetch(fetchImplementation, input, init, hasInit) {
+    // The compiler only rewrites bare `fetch(...)` calls. Calling the captured
+    // function as a local preserves their strict-mode `this === undefined`.
+    // Preserve argument count too: wrappers can distinguish fetch(url) from
+    // fetch(url, undefined).
+    return hasInit ? fetchImplementation(input, init) : fetchImplementation(input);
+  }
+
+  function scheduleFinish(context) {
+    if (!context || context !== active || !context.rootReturned || context.pendingFetches !== 0 || context.finishScheduled) return;
+    context.finishScheduled = true;
+    var finish = function () {
+      context.finishScheduled = false;
+      if (context === active && context.rootReturned && context.pendingFetches === 0) endAction();
+    };
+    if (nativeSetTimeout) nativeSetTimeout(finish, 0);
+    else finish();
+  }
+
+  function correlatedFetch(fetchImplementation, input, init, explicitSites, applicationHasInit) {
+    var hasInit = typeof applicationHasInit === 'boolean' ? applicationHasInit : arguments.length >= 3;
+    var applicationFetch = typeof fetchImplementation === 'function'
+      ? fetchImplementation
+      : nativeFetch;
+    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) {
+      omit(context);
+      return invokeApplicationFetch(applicationFetch, input, init, hasInit);
+    }
+    var fetchInput = input;
+    var fetchInit = init;
+    var normalizedRequest = null;
+    var requestParent = null;
+    var requestSiteId = explicitSites && explicitSites.requestSiteId || context.requestSiteId;
+    var responseSiteId = explicitSites && explicitSites.responseSiteId || context.responseSiteId;
+    try {
+      // A user-defined URL-like object can have stateful coercion. Inspecting
+      // it would perform application work twice, so leave it completely alone
+      // and disclose the missing continuation instead. Objects include Request
+      // and URL here: avoiding `instanceof` also avoids Proxy prototype traps.
+      if (typeof input !== 'string') {
+        omit(context);
+        return invokeApplicationFetch(applicationFetch, input, init, hasInit);
+      }
+      if (!nativeLocationHref || !nativeLocationOrigin || !nativeUrlConstructor ||
+          !nativeUrlCanParse || !nativeRequestConstructor || !nativeHeadersConstructor || !nativeUrlHrefGetter ||
+          !nativeRequestHeadersGetter || !nativeHeadersHas || !nativeHeadersGet || !nativeHeadersSet ||
+          !nativeResponseHeadersGetter || !nativeResponseOkGetter || !nativePromiseReject) {
+        omit(context);
+        return invokeApplicationFetch(applicationFetch, input, init, hasInit);
+      }
+      if (!nativeReflectApply(nativeUrlCanParse, nativeUrlConstructor, [input, nativeLocationHref])) {
+        omit(context);
+        return invokeApplicationFetch(applicationFetch, input, init, hasInit);
+      }
+      var urlValue = nativeReflectConstruct(nativeUrlConstructor, [input, nativeLocationHref]);
+      var inputUrl = nativeReflectApply(nativeUrlHrefGetter, urlValue, []);
+      if (inputUrl.indexOf(nativeLocationOrigin + '/') === 0) {
+        var request = nativeReflectConstruct(nativeRequestConstructor, [input, init]);
+        normalizedRequest = request;
+        // From this point on the application RequestInit has been consumed
+        // exactly once. Any fail-open fetch uses this normalized Request and
+        // never re-reads customer dictionary fields.
+        fetchInput = request;
+        fetchInit = undefined;
+        hasInit = false;
+        var requestHeaders = nativeReflectApply(nativeRequestHeadersGetter, request, []);
+        var headers = nativeReflectConstruct(nativeHeadersConstructor, [requestHeaders]);
+        var reservedHeaders = [TRACE_HEADER, ACTION_HEADER, COHORT_HEADER, PARENT_EVENT_HEADER, REQUEST_SITE_HEADER, 'traceparent'];
+        var hasReservedHeader = false;
+        for (var headerIndex = 0; headerIndex < reservedHeaders.length; headerIndex++) {
+          if (nativeReflectApply(nativeHeadersHas, headers, [reservedHeaders[headerIndex]])) { hasReservedHeader = true; break; }
+        }
+        if (hasReservedHeader) {
+          // Existing application/distributed-tracing headers win. The already
+          // constructed native Request preserves their exact platform
+          // semantics without evaluating the original init twice.
+          omit(context);
+          fetchInput = request;
+          fetchInit = undefined;
+        } else {
+          requestParent = emit(requestSiteId, 'request', 'sent', context.inputEventId || undefined);
+        }
+        if (!requestParent) {
+          // Either a reserved header prevented correlation or event capacity was
+          // exhausted. Invoke the native fetch without adding any header.
+          fetchInput = request;
+          fetchInit = undefined;
+        } else {
+        nativeReflectApply(nativeHeadersSet, headers, [TRACE_HEADER, context.traceId]);
+        nativeReflectApply(nativeHeadersSet, headers, [ACTION_HEADER, context.actionId]);
+        nativeReflectApply(nativeHeadersSet, headers, [COHORT_HEADER, '' + context.cohortIndex]);
+        if (requestParent) nativeReflectApply(nativeHeadersSet, headers, [PARENT_EVENT_HEADER, requestParent]);
+        if (requestParent) nativeReflectApply(nativeHeadersSet, headers, [REQUEST_SITE_HEADER, requestSiteId]);
+        nativeReflectApply(nativeHeadersSet, headers, ['traceparent', traceparent(context.traceId)]);
+        fetchInput = nativeReflectConstruct(nativeRequestConstructor, [request, { headers: headers }]);
+        fetchInit = undefined;
+        }
+      }
+    } catch (error) {
+      failOpen();
+      omit(context);
+      if (normalizedRequest) {
+        // Request conversion already completed. A later telemetry-only failure
+        // must still perform the application fetch exactly once.
+        return invokeApplicationFetch(applicationFetch, normalizedRequest, undefined, false);
+      }
+      // Native fetch reports request-conversion failures asynchronously. Do
+      // the same without retrying the original init and invoking its getters a
+      // second time.
+      return nativeReflectApply(nativePromiseReject, hostPromise, [error]);
+    }
+    // This is the application operation. It must happen exactly once and is
+    // deliberately outside telemetry's catch boundary: a synchronous throw or
+    // rejected promise keeps the application's original semantics.
+    var result = invokeApplicationFetch(applicationFetch, fetchInput, fetchInit, hasInit);
+    if (!requestParent) return result;
+    if (!nativePromiseThen || result === null ||
+        (typeof result !== 'object' && typeof result !== 'function')) {
+      omit(context);
+      scheduleFinish(context);
+      return result;
+    }
+    context.pendingFetches++;
+    try {
+      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])
+              ? nativeReflectApply(nativeHeadersGet, responseHeaders, [PARENT_EVENT_HEADER])
+              : null;
+            var safeServerParent = safeNodeResponseId(context.traceId, requestParent, serverParent);
+            if (serverParent !== null && safeServerParent === null) {
+              omit(context);
+              serverParent = null;
+            } else {
+              serverParent = safeServerParent;
+            }
+            emit(
+              responseSiteId,
+              'response',
+              nativeReflectApply(nativeResponseOkGetter, response, []) ? 'success' : 'error',
+              serverParent || requestParent,
+            );
+          } catch (_) {
+            omit(context);
+            failOpen();
+          }
+          scheduleFinish(context);
+        }
+      }, function (error) {
+        context.pendingFetches--;
+        if (context === active) {
+          try { emit(responseSiteId, 'response', 'network:error', requestParent); } catch (_) { failOpen(); }
+          scheduleFinish(context);
+        }
+        // Preserve an unhandled rejection signal for ignored application fetch
+        // Promises. It is carried by this observer child rather than the exact
+        // original Promise identity.
+        throw error;
+      }]);
+    } catch (_) {
+      context.pendingFetches--;
+      omit(context);
+      scheduleFinish(context);
+      failOpen();
+    }
+    // Observation must not replace the application's Promise or call a
+    // customer-overridden `.then` method.
+    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) 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) {
+        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 (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' },
+        });
+      } 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;
+      var value = manifest();
+      var action = actionFor(actionId);
+      if (!value || !action || !sites || sessionCohort(value.cohortCount) !== action.cohortIndex) return false;
+      var traceId = randomTraceId();
+      if (!traceId) return false;
+      active = {
+        traceId: traceId,
+        actionId: actionId,
+        cohortIndex: action.cohortIndex,
+        events: [],
+        omittedEvents: 0,
+        parentEventId: null,
+        requestSiteId: sites.requestSiteId,
+        responseSiteId: sites.responseSiteId,
+        pendingFetches: 0,
+        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;
+    } catch (_) {
+      failOpen();
+      active = null;
+      return false;
+    }
+  }
+
+  function wrapAction(actionId, handler) {
+    if (typeof handler !== 'function') return handler;
+    return function haystackWebAtlasActionWrapper() {
+      var sites = runtimeActions[actionId];
+      if (!sites) return nativeReflectApply(handler, this, arguments);
+      if (active) {
+        // 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);
+      var context = active;
+      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;
+        if (context === active) endAction();
+        throw error;
+      } finally {
+        directProbeContext = previousDirectProbeContext;
+      }
+
+      // Keep a real Promise-returning action open across awaits. We attach a
+      // side observer through the captured native Promise method and return the
+      // application's original Promise unchanged.
+      var observesPromise = false;
+      if (context && nativePromiseThen && result !== null &&
+          (typeof result === 'object' || typeof result === 'function')) {
+        try {
+          nativeReflectApply(nativePromiseThen, result, [function (value) {
+            if (context === active) {
+              if (!context.saturated) {
+                emit(sites.outputSiteId, 'output-shape', shapeOutcome(value), context.inputEventId || undefined);
+              }
+              context.rootReturned = true;
+              scheduleFinish(context);
+            }
+          }, function (error) {
+            if (context === active) {
+              context.rootReturned = true;
+              scheduleFinish(context);
+            }
+            // Do not hide ignored async-handler failures from error monitoring.
+            throw error;
+          }]);
+          observesPromise = true;
+        } catch (_) { failOpen(); }
+      }
+      if (!observesPromise) {
+        if (context && !nativePromiseThen && result !== null &&
+            (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);
+        }
+      }
+      return result;
+    };
+  }
+
+  function conditionAt(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) 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;
+      var value = manifest();
+      var segment = {
+        schemaVersion: 'haystack-web-node-atlas-segment-v1',
+        traceId: active.traceId,
+        actionId: active.actionId,
+        surface: 'browser',
+        buildId: value.browserBuildId,
+        cohortIndex: active.cohortIndex,
+        events: active.events.slice(),
+        omittedEvents: active.omittedEvents,
+      };
+      active = null;
+      deliver(segment);
+      return segment;
+    } catch (_) {
+      failOpen();
+      active = null;
+      return null;
+    }
+  }
+
+  var api = Object.freeze({
+    version: 'haystack-web-node-atlas-browser-v1',
+    configure: configure,
+    registerAction: registerAction,
+    beginAction: beginAction,
+    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,
+    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,
+          saturated: active.saturated,
+          events: active.events.length,
+          omittedEvents: active.omittedEvents,
+          traceId: active.traceId,
+        }
+        : { active: false, disabled: recorderDisabled };
+    },
+  });
+  try {
+    Object.defineProperty(host, '__haystackWebAtlas', {
+      configurable: false,
+      enumerable: false,
+      writable: false,
+      value: api,
+    });
+  } catch (_) {
+    // The application owns this namespace. Never redefine or mutate it, and
+    // never prevent the containing module from evaluating.
+    return null;
+  }
+  return api;
+})(globalThis);