@haystackeditor/cli 0.15.25 → 0.15.27

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

@@ -0,0 +1,861 @@
+/*
+ * 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 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 nativeGetPrototypeOf = Object.getPrototypeOf;
+  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 recorderDisabled = 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 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 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_EVENTS || fetchPairs.length > MAX_EVENTS) 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]) ||
+              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']);
+        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) 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++;
+        return null;
+      }
+      if (active.events.length >= MAX_EVENTS) {
+        active.omittedEvents++;
+        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);
+      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);
+    // 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++;
+      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') {
+        context.omittedEvents++;
+        return invokeApplicationFetch(applicationFetch, input, init, hasInit);
+      }
+      if (!nativeLocationHref || !nativeLocationOrigin || !nativeUrlConstructor ||
+          !nativeUrlCanParse || !nativeRequestConstructor || !nativeHeadersConstructor || !nativeUrlHrefGetter ||
+          !nativeRequestHeadersGetter || !nativeHeadersHas || !nativeHeadersGet || !nativeHeadersSet ||
+          !nativeResponseHeadersGetter || !nativeResponseOkGetter || !nativePromiseReject) {
+        context.omittedEvents++;
+        return invokeApplicationFetch(applicationFetch, input, init, hasInit);
+      }
+      if (!nativeReflectApply(nativeUrlCanParse, nativeUrlConstructor, [input, nativeLocationHref])) {
+        context.omittedEvents++;
+        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.
+          context.omittedEvents++;
+          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();
+      context.omittedEvents++;
+      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')) {
+      context.omittedEvents++;
+      scheduleFinish(context);
+      return result;
+    }
+    context.pendingFetches++;
+    try {
+      nativeReflectApply(nativePromiseThen, result, [function (response) {
+        context.pendingFetches--;
+        if (context === active) {
+          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) {
+              context.omittedEvents++;
+              serverParent = null;
+            } else {
+              serverParent = safeServerParent;
+            }
+            emit(
+              responseSiteId,
+              'response',
+              nativeReflectApply(nativeResponseOkGetter, response, []) ? 'success' : 'error',
+              serverParent || requestParent,
+            );
+          } catch (_) {
+            context.omittedEvents++;
+            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--;
+      context.omittedEvents++;
+      scheduleFinish(context);
+      failOpen();
+    }
+    // Observation must not replace the application's Promise or call a
+    // customer-overridden `.then` method.
+    return result;
+  }
+
+  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++;
+      return nativeReflectApply(fetchImplementation, undefined, passthroughArguments);
+    }
+    var hasInit = arguments.length >= 4;
+    var context = active;
+    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 deliver(segment) {
+    try {
+      var endpoint = configuredEndpoint || ownDataValue('__HAYSTACK_WEB_ATLAS_ENDPOINT__');
+      if (typeof endpoint !== 'string' || endpoint.length === 0) return false;
+      var body = nativeStringify(segment);
+      if (nativeBeacon && nativeBeacon(endpoint, body)) return true;
+      if (nativeFetch && configuredPlatformFetch && initialFetchLooksNative) {
+        var 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 (_) { failOpen(); }
+    return false;
+  }
+
+  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,
+      };
+      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 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);
+      }
+      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;
+      try {
+        result = nativeReflectApply(handler, this, arguments);
+      } catch (error) {
+        if (context) context.rootReturned = true;
+        endAction();
+        throw error;
+      }
+
+      // 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) {
+              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')) context.omittedEvents++;
+        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;
+      var siteId = context && context.runtimeConfig && context.runtimeConfig.conditionSites[token];
+      if (siteId) emit(siteId, 'condition', value ? 'boolean:true' : 'boolean:false', 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) { emit(siteId, 'input-shape', outcome); },
+    condition: function (siteId, outcome) { emit(siteId, 'condition', outcome); },
+    fetch: correlatedFetch,
+    fetchAt: fetchAt,
+    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); },
+    endAction: endAction,
+    status: function () {
+      return active
+        ? { active: true, disabled: recorderDisabled, 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);