@haystackeditor/cli 0.15.26 → 0.15.27

package/dist/assets/telemetry/runtime.cjs

@@ -0,0 +1,1509 @@
+'use strict';
+
+/*
+ * Haystack's automatically injected Node telemetry runtime.
+ *
+ * This file is copied beside compiled application code by
+ * `haystack telemetry instrument`. It has no package dependencies, records no
+ * raw values, and is inert unless all three HAYSTACK_TELEMETRY_* activation
+ * variables are present. Every application-facing hook returns the original
+ * value and catches its own errors so telemetry cannot change app behavior.
+ */
+
+const { createHash, randomBytes } = require('node:crypto');
+const { AsyncLocalStorage } = require('node:async_hooks');
+const diagnosticsChannel = require('node:diagnostics_channel');
+const { types: utilTypes } = require('node:util');
+const { mkdirSync, readFileSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync } = require('node:fs');
+const { tmpdir } = require('node:os');
+const { join } = require('node:path');
+
+// Capture the few mutable language intrinsics used on customer values before
+// application code runs. Calling a customer-patched prototype method from a
+// probe would itself be an application-visible side effect.
+const safeStringTrim = Function.call.bind(String.prototype.trim);
+const safeString = String;
+const safeStringStartsWith = Function.call.bind(String.prototype.startsWith);
+const safeStringEndsWith = Function.call.bind(String.prototype.endsWith);
+const safeStringIndexOf = Function.call.bind(String.prototype.indexOf);
+const safeStringSlice = Function.call.bind(String.prototype.slice);
+const safeStringCharCodeAt = Function.call.bind(String.prototype.charCodeAt);
+const safeRegExpTest = Function.call.bind(RegExp.prototype.test);
+const safeJsonParse = JSON.parse;
+const safeJsonStringify = JSON.stringify;
+const safeArrayIsArray = Array.isArray;
+const safeArrayFilter = Function.call.bind(Array.prototype.filter);
+const safeArrayFind = Function.call.bind(Array.prototype.find);
+const safeArrayFlatMap = Function.call.bind(Array.prototype.flatMap);
+const safeArrayMap = Function.call.bind(Array.prototype.map);
+const safeArrayReduce = Function.call.bind(Array.prototype.reduce);
+const safeArrayShift = Function.call.bind(Array.prototype.shift);
+const safeArraySlice = Function.call.bind(Array.prototype.slice);
+const safeArraySort = Function.call.bind(Array.prototype.sort);
+const safeNumber = Number;
+const safeNumberIsFinite = Number.isFinite;
+const safeNumberIsSafeInteger = Number.isSafeInteger;
+const safeNumberParseInt = Number.parseInt;
+const safeMathImul = Math.imul;
+const safeMathMax = Math.max;
+const safeMathMin = Math.min;
+const safeBufferByteLength = Buffer.byteLength;
+const safeObjectKeys = Object.keys;
+const safeObjectEntries = Object.entries;
+const safeObjectCreate = Object.create;
+const safeGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+const safeGetPrototypeOf = Object.getPrototypeOf;
+const safeHasOwn = Function.call.bind(Object.prototype.hasOwnProperty);
+const safeMapGet = Function.call.bind(Map.prototype.get);
+const safeMapSet = Function.call.bind(Map.prototype.set);
+const safeMapHas = Function.call.bind(Map.prototype.has);
+const safeMapSize = Function.call.bind(Object.getOwnPropertyDescriptor(Map.prototype, 'size').get);
+const safeMapEntries = Function.call.bind(Map.prototype.entries);
+const safeMapValues = Function.call.bind(Map.prototype.values);
+const safeWeakMapGet = Function.call.bind(WeakMap.prototype.get);
+const safeWeakMapSet = Function.call.bind(WeakMap.prototype.set);
+const safeSetAdd = Function.call.bind(Set.prototype.add);
+const safeSetValues = Function.call.bind(Set.prototype.values);
+const safeArrayPush = Function.call.bind(Array.prototype.push);
+const SafeMap = Map;
+const SafeSet = Set;
+const SafeWeakMap = WeakMap;
+const SafeDate = Date;
+const safeDateNow = Date.now;
+const safeDateToISOString = Function.call.bind(Date.prototype.toISOString);
+const safeMapIteratorNext = Function.call.bind(
+  Object.getPrototypeOf(safeMapEntries(new SafeMap())).next,
+);
+const safeSetIteratorNext = Function.call.bind(
+  Object.getPrototypeOf(safeSetValues(new SafeSet())).next,
+);
+const hashPrototype = Object.getPrototypeOf(createHash('sha256'));
+const safeHashUpdate = Function.call.bind(hashPrototype.update);
+const safeHashDigest = Function.call.bind(hashPrototype.digest);
+const safeIsProxy = utilTypes.isProxy;
+const safeIsNativeError = utilTypes.isNativeError;
+const safeActionGetStore = Function.call.bind(AsyncLocalStorage.prototype.getStore);
+const safeActionEnterWith = Function.call.bind(AsyncLocalStorage.prototype.enterWith);
+const safePromiseFinally = Function.call.bind(Promise.prototype.finally);
+const safeFetch = typeof fetch === 'function' ? fetch : null;
+const safeAbortTimeout = typeof AbortSignal?.timeout === 'function' ? AbortSignal.timeout : null;
+const safeResponseOk = typeof Response === 'function'
+  ? Function.call.bind(Object.getOwnPropertyDescriptor(Response.prototype, 'ok').get)
+  : null;
+const safeResponseStatus = typeof Response === 'function'
+  ? Function.call.bind(Object.getOwnPropertyDescriptor(Response.prototype, 'status').get)
+  : null;
+const safeClearInterval = clearInterval;
+const SafeError = Error;
+const nativeErrorPrototypes = Object.freeze({
+  type: TypeError.prototype,
+  range: RangeError.prototype,
+  syntax: SyntaxError.prototype,
+  reference: ReferenceError.prototype,
+  aggregate: typeof AggregateError === 'function' ? AggregateError.prototype : null,
+  uri: URIError.prototype,
+  eval: EvalError.prototype,
+  generic: Error.prototype,
+});
+
+function compareStrings(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+
+function mapEntriesArray(map) {
+  const result = [];
+  const iterator = safeMapEntries(map);
+  while (true) {
+    const step = safeMapIteratorNext(iterator);
+    if (step.done) return result;
+    safeArrayPush(result, step.value);
+  }
+}
+
+function mapValuesArray(map) {
+  const entries = mapEntriesArray(map);
+  const result = [];
+  for (let index = 0; index < entries.length; index++) safeArrayPush(result, entries[index][1]);
+  return result;
+}
+
+function setValuesArray(set) {
+  const result = [];
+  const iterator = safeSetValues(set);
+  while (true) {
+    const step = safeSetIteratorNext(iterator);
+    if (step.done) return result;
+    safeArrayPush(result, step.value);
+  }
+}
+
+function objectFromEntryArray(entries) {
+  const result = safeObjectCreate(null);
+  for (let index = 0; index < entries.length; index++) {
+    const entry = entries[index];
+    result[entry[0]] = entry[1];
+  }
+  return result;
+}
+
+function objectFromMap(map) {
+  return objectFromEntryArray(mapEntriesArray(map));
+}
+
+function sha256Hex(value) {
+  const hash = createHash('sha256');
+  safeHashUpdate(hash, value);
+  return safeHashDigest(hash, 'hex');
+}
+
+function responseAccepted(response) {
+  try {
+    return safeResponseOk ? safeResponseOk(response) : false;
+  } catch {
+    return false;
+  }
+}
+
+function responseStatus(response) {
+  try {
+    return safeResponseStatus ? safeResponseStatus(response) : 0;
+  } catch {
+    return 0;
+  }
+}
+
+const RUNTIME_VERSION = 1;
+const SAMPLER_VERSION = 3;
+const DEFAULT_FLUSH_INTERVAL_MS = 60_000;
+const DEFAULT_SITE_OBSERVATIONS = 8;
+const MAX_SITE_OBSERVATIONS = 4_096;
+const MAX_SAFE_COUNT = Number.MAX_SAFE_INTEGER;
+const MAX_COUNTER_KEYS = 50_000;
+const MAX_EXECUTION_FAMILIES = 64;
+const MAX_EXECUTION_EVENTS = 48;
+const MAX_EXECUTION_ACTION_BYTES = 24 * 1024;
+const MAX_EXECUTION_BYTES = 1024 * 1024;
+const MAX_PAYLOAD_BYTES = 4 * 1024 * 1024;
+const PAYLOAD_CHUNK_BUDGET = MAX_PAYLOAD_BYTES - 256 * 1024;
+const MAX_SPOOL_FILES = 8;
+const MAX_SPOOL_BYTES = 16 * 1024 * 1024;
+const SAMPLE_FIRST_ACTIONS = 4;
+const DEFAULT_PROCESS_SAMPLE_RATE = 1;
+const DEFAULT_ACTION_SAMPLE_RATE = 64;
+const MAX_ACTION_SAMPLE_RATE = 4_096;
+const MAX_CONSECUTIVE_FAILURES = 3;
+const CONTROL_GLOBAL = '__haystackTelemetryControlV1';
+const CONTROL_CHANNEL = '__HAYSTACK_TELEMETRY_CONTROL_CHANNEL__';
+const RUNTIME_INTEGRITY = '__HAYSTACK_TELEMETRY_RUNTIME_INTEGRITY__';
+const SUPPRESSED_ACTION = Object.freeze({ suppressed: true });
+
+let installed = false;
+let activeControl = null;
+const processHost = require('node:process');
+
+function selectProbe(name, fallback) {
+  try {
+    const selected = activeControl?.selectProbe(name);
+    return typeof selected === 'function' ? selected : fallback;
+  } catch {
+    return fallback;
+  }
+}
+
+function trustedSelectProbe(name, fallback) {
+  return selectProbe(name, fallback);
+}
+
+Object.defineProperty(trustedSelectProbe, 'haystackRuntimeIntegrity', {
+  configurable: false,
+  enumerable: false,
+  writable: false,
+  value: RUNTIME_INTEGRITY,
+});
+
+function safeSelectProbe(expectedIntegrity, name, fallback) {
+  try {
+    if (expectedIntegrity !== RUNTIME_INTEGRITY) return fallback;
+    return trustedSelectProbe(name, fallback);
+  } catch {
+    return fallback;
+  }
+}
+
+function safeSelectSiteProbe(expectedIntegrity, name, site, fallback) {
+  try {
+    if (expectedIntegrity !== RUNTIME_INTEGRITY) return fallback;
+    const selected = activeControl?.selectSiteProbe(name, site);
+    return typeof selected === 'function' ? selected : fallback;
+  } catch {
+    return fallback;
+  }
+}
+
+function debug(message, error) {
+  if (process.env.HAYSTACK_TELEMETRY_DEBUG !== '1') return;
+  const detail = safeIsNativeError(error) ? ': native error' : error ? ': telemetry error' : '';
+  process.stderr.write(`[haystack-telemetry] ${message}${detail}\n`);
+}
+
+function safeSegment(value, fallback) {
+  return typeof value === 'string' && safeRegExpTest(/^[A-Za-z0-9._-]{1,128}$/, value) ? value : fallback;
+}
+
+function sizeBucket(length) {
+  if (length === 0) return 'empty';
+  if (length === 1) return 'one';
+  if (length <= 4) return 'few';
+  return 'many';
+}
+
+function stringForm(value) {
+  if (value.length === 0) return 'empty';
+  const trimmed = safeStringTrim(value);
+  if (!trimmed) return 'whitespace';
+  // Bound parsing work. Long strings still report their generic form/size;
+  // their contents are never retained or transmitted.
+  if (trimmed.length <= 4_096 && safeStringStartsWith(trimmed, '```') && safeStringEndsWith(trimmed, '```')) {
+    const newline = safeStringIndexOf(trimmed, '\n');
+    if (newline >= 0) {
+      const body = safeStringTrim(safeStringSlice(trimmed, newline + 1, -3));
+      try {
+        const parsed = safeJsonParse(body);
+        return safeArrayIsArray(parsed)
+          ? 'markdown-fenced-json-array'
+          : parsed !== null && typeof parsed === 'object'
+            ? 'markdown-fenced-json-object'
+            : 'markdown-fenced-json-scalar';
+      } catch {
+        return 'markdown-fenced-text';
+      }
+    }
+    return 'markdown-fenced-text';
+  }
+  if (trimmed.length <= 4_096) {
+    try {
+      const parsed = safeJsonParse(trimmed);
+      return safeArrayIsArray(parsed)
+        ? 'json-array'
+        : parsed !== null && typeof parsed === 'object'
+          ? 'json-object'
+          : 'json-scalar';
+    } catch {
+      // Ordinary text is the expected case.
+    }
+  }
+  return 'text';
+}
+
+function valueShape(value) {
+  if (value === null) return 'null';
+  if (value === undefined) return 'undefined';
+  if (typeof value === 'string') return `string:${stringForm(value)}:${sizeBucket(value.length)}`;
+  if (typeof value === 'number') return safeNumberIsFinite(value) ? 'number:finite' : 'number:nonfinite';
+  if (typeof value === 'boolean') return 'boolean';
+  if (typeof value === 'object' && safeIsProxy(value)) return 'object:uninspectable';
+  if (safeArrayIsArray(value)) return `array:${sizeBucket(value.length)}`;
+  if (typeof value === 'object') {
+    try {
+      if (safeIsNativeError(value)) return `error:${errorClass(value)}`;
+      return `object:${sizeBucket(safeObjectKeys(value).length)}`;
+    } catch {
+      return 'object:uninspectable';
+    }
+  }
+  return `nonjson:${typeof value}`;
+}
+
+function stableIdentity(prefix, parts) {
+  let framed = '';
+  for (let index = 0; index < parts.length; index++) {
+    if (index > 0) framed += '|';
+    const part = parts[index];
+    framed += `${safeBufferByteLength(part, 'utf8')}:${part}`;
+  }
+  return `${prefix}-${safeStringSlice(sha256Hex(framed), 0, 24)}`;
+}
+
+function canonicalJson(value) {
+  if (value === null || typeof value !== 'object') return safeJsonStringify(value);
+  if (safeArrayIsArray(value)) {
+    let result = '[';
+    for (let index = 0; index < value.length; index++) {
+      if (index > 0) result += ',';
+      result += canonicalJson(value[index]);
+    }
+    return `${result}]`;
+  }
+  const keys = safeArraySort(safeObjectKeys(value), compareStrings);
+  let result = '{';
+  for (let index = 0; index < keys.length; index++) {
+    if (index > 0) result += ',';
+    const key = keys[index];
+    result += `${safeJsonStringify(key)}:${canonicalJson(value[key])}`;
+  }
+  return `${result}}`;
+}
+
+function errorClass(value) {
+  try {
+    if (value !== null && typeof value === 'object' && safeIsProxy(value)) return 'uninspectable';
+    if (safeIsNativeError(value)) {
+      // Compare the direct native prototype with references captured before
+      // application code. This retains common built-in classes without
+      // invoking mutable Symbol.hasInstance/name/tag hooks.
+      const prototype = safeGetPrototypeOf(value);
+      if (prototype === nativeErrorPrototypes.type) return 'type';
+      if (prototype === nativeErrorPrototypes.range) return 'range';
+      if (prototype === nativeErrorPrototypes.syntax) return 'syntax';
+      if (prototype === nativeErrorPrototypes.reference) return 'reference';
+      if (prototype === nativeErrorPrototypes.aggregate) return 'aggregate';
+      if (prototype === nativeErrorPrototypes.uri) return 'uri';
+      if (prototype === nativeErrorPrototypes.eval) return 'eval';
+      return 'generic';
+    }
+  } catch {
+    return 'uninspectable';
+  }
+  if (value === null) return 'non-error-null';
+  return `non-error-${typeof value}`;
+}
+
+function httpMethod(value) {
+  return value === 'GET' || value === 'POST' || value === 'PUT' || value === 'PATCH' ||
+    value === 'DELETE' || value === 'HEAD' || value === 'OPTIONS' ? value : 'OTHER';
+}
+
+function hashSeed(value) {
+  let hash = 0x811c9dc5;
+  for (let index = 0; index < value.length; index++) {
+    hash ^= safeStringCharCodeAt(value, index);
+    hash = safeMathImul(hash, 0x01000193);
+  }
+  return (hash >>> 0) || 1;
+}
+
+function validEndpoint(raw) {
+  try {
+    const endpoint = new URL(raw);
+    if (endpoint.protocol === 'https:') return endpoint.toString();
+    if (endpoint.protocol === 'http:' && (endpoint.hostname === '127.0.0.1' ||
+        endpoint.hostname === 'localhost' || endpoint.hostname === '::1')) {
+      return endpoint.toString();
+    }
+  } catch {
+    // Invalid URLs simply leave telemetry disabled.
+  }
+  return null;
+}
+
+function loadInstrumentation() {
+  try {
+    const manifest = safeJsonParse(readFileSync(join(__dirname, 'instrumentation.json'), 'utf8'));
+    if (manifest.schema_version !== 'haystack-node-telemetry-instrumentation-v3' ||
+        !safeArrayIsArray(manifest.sites)) return { sites: new SafeMap(), entrySourcePath: null };
+    const siteEntries = safeArrayMap(manifest.sites, site => [site.probe_key, Object.freeze({
+      probeKey: site.probe_key,
+      siteId: site.site_id,
+      sourcePath: site.source_path,
+      qualifiedName: site.qualified_name,
+      probeKind: site.probe_kind,
+      ownerKey: site.owner_key,
+      structuralKey: site.structural_key,
+      ...(site.label ? { label: site.label } : {}),
+      allowedFields: safeArrayIsArray(site.allowed_fields)
+        ? safeArraySlice(site.allowed_fields, 0)
+        : [],
+    })]);
+    const sites = new SafeMap();
+    for (let index = 0; index < siteEntries.length; index++) {
+      safeMapSet(sites, siteEntries[index][0], siteEntries[index][1]);
+    }
+    const entryFile = safeArrayIsArray(manifest.instrumented_files)
+      ? safeArrayFind(manifest.instrumented_files, file => file.output_path === manifest.entry)
+      : null;
+    return {
+      sites,
+      buildId: safeSegment(manifest.build_id, 'unknown'),
+      entrySourcePath: typeof entryFile?.source_path === 'string' ? entryFile.source_path : null,
+    };
+  } catch (error) {
+    debug('instrumentation manifest could not be read; telemetry stayed disabled', error);
+    return { sites: new SafeMap(), buildId: 'unknown', entrySourcePath: null };
+  }
+}
+
+function installRuntime(options = {}) {
+  if (installed) return activeControl ?? { enabled: false, reason: 'already-installed' };
+  installed = true;
+
+  const endpoint = validEndpoint(process.env.HAYSTACK_TELEMETRY_ENDPOINT ?? '');
+  const token = process.env.HAYSTACK_TELEMETRY_TOKEN;
+  if (process.env.HAYSTACK_TELEMETRY !== '1' || !endpoint || !token || !safeFetch || !safeAbortTimeout) {
+    return { enabled: false, reason: 'not-configured' };
+  }
+  if (CONTROL_CHANNEL in processHost) {
+    debug('telemetry control name is already owned; telemetry stayed disabled');
+    return { enabled: false, reason: 'global-conflict' };
+  }
+
+  // The manifest-derived build identity is part of every exact DDB family ID.
+  // Do not accept a runtime override that could merge unrelated builds.
+  const instrumentation = loadInstrumentation();
+  const buildId = instrumentation.buildId;
+  const sitesByProbe = instrumentation.sites;
+  const sitesById = new SafeMap();
+  const probeStates = new SafeMap();
+  const siteValues = mapValuesArray(sitesByProbe);
+  for (let index = 0; index < siteValues.length; index++) {
+    const metadata = siteValues[index];
+    safeMapSet(sitesById, metadata.siteId, metadata);
+    safeMapSet(probeStates, metadata.probeKey, {
+      metadata,
+      calls: 0,
+      saturated: false,
+      omitted: 0,
+    });
+  }
+  if (safeMapSize(sitesByProbe) === 0) return { enabled: false, reason: 'missing-instrumentation-manifest' };
+  const runId = safeSegment(
+    process.env.HAYSTACK_TELEMETRY_RUN_ID,
+    `${safeDateNow()}-${process.pid}-${randomBytes(4).toString('hex')}`,
+  );
+  const intervalRequested = safeNumberParseInt(process.env.HAYSTACK_TELEMETRY_FLUSH_INTERVAL_MS ?? '', 10);
+  const flushIntervalMs = safeNumberIsSafeInteger(intervalRequested) && intervalRequested >= 100
+    ? intervalRequested
+    : DEFAULT_FLUSH_INTERVAL_MS;
+  const requestedSiteObservations = safeNumberParseInt(
+    process.env.HAYSTACK_TELEMETRY_SITE_OBSERVATIONS ?? '',
+    10,
+  );
+  const siteObservationLimit = safeNumberIsSafeInteger(requestedSiteObservations) &&
+    requestedSiteObservations >= 1 && requestedSiteObservations <= MAX_SITE_OBSERVATIONS
+    ? requestedSiteObservations
+    : DEFAULT_SITE_OBSERVATIONS;
+  const requestedProcessSampleRate = safeNumberParseInt(
+    process.env.HAYSTACK_TELEMETRY_PROCESS_SAMPLE_RATE ?? '',
+    10,
+  );
+  const processSampleRate = safeNumberIsSafeInteger(requestedProcessSampleRate) &&
+    requestedProcessSampleRate >= 0 && requestedProcessSampleRate <= MAX_ACTION_SAMPLE_RATE
+    ? requestedProcessSampleRate
+    : DEFAULT_PROCESS_SAMPLE_RATE;
+  const requestedActionSampleRate = safeNumberParseInt(
+    process.env.HAYSTACK_TELEMETRY_ACTION_SAMPLE_RATE ?? '',
+    10,
+  );
+  const actionSampleRate = safeNumberIsSafeInteger(requestedActionSampleRate) &&
+    requestedActionSampleRate >= 1 && requestedActionSampleRate <= MAX_ACTION_SAMPLE_RATE
+    ? requestedActionSampleRate
+    : DEFAULT_ACTION_SAMPLE_RATE;
+
+  let enabled = true;
+  let sequence = 0;
+  let consecutiveFailures = 0;
+  let currentShape = new SafeMap();
+  let currentBranch = new SafeMap();
+  let currentExecutions = new SafeMap();
+  let currentExecutionBytes = 0;
+  let omittedExecutionFamilyObservations = 0;
+  let sampledActions = 0;
+  let unsampledActions = 0;
+  let currentOmissions = new SafeMap();
+  let saturatedProbeOmissions = 0;
+  let pending = null;
+  let pendingQueue = [];
+  let flushInFlight = null;
+  let beforeExitStarted = false;
+  const actionStorage = new AsyncLocalStorage();
+  const httpActions = new SafeWeakMap();
+  let actionSequence = 0;
+  const actionSeed = hashSeed(`${buildId}:${runId}`);
+  let processSelected = true;
+  let hasChildActions = false;
+
+  function shouldSampleAction(actionKind) {
+    const sequence = actionSequence++;
+    if (actionKind !== 'process' && !processSelected) {
+      unsampledActions++;
+      return false;
+    }
+    if (actionKind !== 'process' && sequence <= SAMPLE_FIRST_ACTIONS) {
+      sampledActions++;
+      return true;
+    }
+    const rate = actionKind === 'process' ? processSampleRate : actionSampleRate;
+    const sampled = rate === 1 || (rate > 1 &&
+      ((actionSeed + safeMathImul(sequence + 1, 0x9e3779b1)) >>> 0) % rate === 0);
+    if (actionKind === 'process') processSelected = sampled;
+    if (sampled) sampledActions++;
+    else unsampledActions++;
+    return sampled;
+  }
+
+  function startAction(actionKind, actionSiteId, actionMethod) {
+    if (!shouldSampleAction(actionKind)) return SUPPRESSED_ACTION;
+    return {
+      suppressed: false,
+      actionKind,
+      actionSiteId,
+      actionMethod,
+      events: [],
+      eventBytes: 0,
+      truncated: false,
+      omittedEvents: 0,
+      finalized: false,
+      outcome: null,
+      terminalError: 'none',
+    };
+  }
+
+  function actionForProbe() {
+    const action = hasChildActions ? safeActionGetStore(actionStorage) : processAction;
+    return action && !action.finalized ? action : null;
+  }
+
+  function omitExecutionEvents(action, count = 1) {
+    if (!action || action.suppressed || count < 1) return;
+    action.truncated = true;
+    action.omittedEvents = safeMathMin(MAX_SAFE_COUNT, action.omittedEvents + count);
+  }
+
+  function currentAction() {
+    const action = actionForProbe();
+    return action && !action.suppressed ? action : null;
+  }
+
+  function passThrough(_site, value) {
+    return value;
+  }
+
+  function addExecutionEvent(site, kind, scope, outcome) {
+    const action = currentAction();
+    if (!action) return;
+    if (action.truncated) {
+      omitExecutionEvents(action);
+      return;
+    }
+    const metadata = safeMapGet(sitesByProbe, site);
+    if (!metadata) return;
+    const previous = action.events[action.events.length - 1];
+    if (previous && previous.siteId === metadata.siteId && previous.kind === kind &&
+        previous.scope === scope && previous.outcome === outcome) {
+      previous.observations++;
+      return;
+    }
+    const event = {
+      siteId: metadata.siteId,
+      kind,
+      scope,
+      outcome,
+      observations: 1,
+    };
+    const eventBytes = safeBufferByteLength(safeJsonStringify({
+      ...event,
+      sourcePath: metadata.sourcePath,
+      qualifiedName: metadata.qualifiedName,
+      probeKind: metadata.probeKind,
+    }), 'utf8');
+    if (action.events.length >= MAX_EXECUTION_EVENTS ||
+        action.eventBytes + eventBytes > MAX_EXECUTION_ACTION_BYTES) {
+      action.truncated = true;
+      omitExecutionEvents(action);
+      return;
+    }
+    safeArrayPush(action.events, event);
+    action.eventBytes += eventBytes;
+  }
+
+  function finalizeAction(action, outcome) {
+    if (!action || action.suppressed || action.finalized) return;
+    action.finalized = true;
+    action.outcome = outcome;
+    if (action.events.length === 0) {
+      if (action.omittedEvents > 0 && omittedExecutionFamilyObservations < MAX_SAFE_COUNT) {
+        omittedExecutionFamilyObservations++;
+      }
+      return;
+    }
+    const sketch = {
+      actionKind: action.actionKind,
+      actionSiteId: action.actionSiteId,
+      actionMethod: action.actionMethod,
+      outcome,
+      terminalError: action.terminalError,
+      truncated: action.truncated,
+      omittedEvents: action.omittedEvents,
+      events: action.events,
+    };
+    const familyId = stableIdentity('execution-local-family', [canonicalJson(sketch)]);
+    const existing = safeMapGet(currentExecutions, familyId);
+    if (existing) {
+      existing.observations++;
+      return;
+    }
+    const sketchBytes = action.eventBytes + safeBufferByteLength(safeJsonStringify(sketch), 'utf8');
+    if (safeMapSize(currentExecutions) >= MAX_EXECUTION_FAMILIES ||
+        currentExecutionBytes + sketchBytes > MAX_EXECUTION_BYTES) {
+      omittedExecutionFamilyObservations++;
+      return;
+    }
+    safeMapSet(currentExecutions, familyId, { familyId, observations: 1, ...sketch });
+    currentExecutionBytes += sketchBytes;
+  }
+
+  let processAction = startAction(
+    'process',
+    stableIdentity('action-site', [instrumentation.entrySourcePath || 'unknown-entry']),
+    'NONE',
+  );
+  safeActionEnterWith(actionStorage, processAction);
+
+  function continueProcessAction() {
+    if (processAction.suppressed) return;
+    const previous = processAction;
+    const active = safeActionGetStore(actionStorage);
+    processAction = {
+      suppressed: false,
+      actionKind: processAction.actionKind,
+      actionSiteId: processAction.actionSiteId,
+      actionMethod: processAction.actionMethod,
+      events: [],
+      eventBytes: 0,
+      truncated: false,
+      omittedEvents: 0,
+      finalized: false,
+      outcome: null,
+      terminalError: 'none',
+    };
+    if (!hasChildActions || !active || active === previous) {
+      safeActionEnterWith(actionStorage, processAction);
+    }
+  }
+
+  try {
+    const requestStart = diagnosticsChannel.channel('http.server.request.start');
+    const responseFinish = diagnosticsChannel.channel('http.server.response.finish');
+    requestStart.subscribe((message) => {
+      try {
+        hasChildActions = true;
+        const action = startAction(
+          'http-server',
+          stableIdentity('action-site', ['node:http-server']),
+          httpMethod(message?.request?.method),
+        );
+        safeActionEnterWith(actionStorage, action);
+        if (message?.response && typeof message.response === 'object') {
+          safeWeakMapSet(httpActions, message.response, action);
+        }
+      } catch (error) {
+        debug('HTTP action start failed open', error);
+      }
+    });
+    responseFinish.subscribe((message) => {
+      try {
+        const action = message?.response && typeof message.response === 'object'
+          ? safeWeakMapGet(httpActions, message.response)
+          : null;
+        const response = message?.response;
+        const statusDescriptor = response && typeof response === 'object' && !safeIsProxy(response)
+          ? safeGetOwnPropertyDescriptor(response, 'statusCode')
+          : null;
+        const status = statusDescriptor && safeHasOwn(statusDescriptor, 'value')
+          ? safeNumber(statusDescriptor.value)
+          : NaN;
+        const outcome = !safeNumberIsFinite(status)
+          ? 'completed'
+          : status >= 500
+            ? 'server-error'
+            : status >= 400
+              ? 'client-error'
+              : 'success';
+        finalizeAction(action, outcome);
+      } catch (error) {
+        debug('HTTP action finish failed open', error);
+      }
+    });
+  } catch (error) {
+    debug('HTTP action correlation unavailable', error);
+  }
+
+  function recordOmission(site, field) {
+    const current = safeMapGet(currentOmissions, site) || {
+      counterObservations: 0,
+      probeObservations: 0,
+    };
+    current[field]++;
+    safeMapSet(currentOmissions, site, current);
+  }
+
+  function disable(reason, error) {
+    enabled = false;
+    safeClearInterval(timer);
+    debug(`disabled after ${reason}`, error);
+  }
+
+  function sampleWeight(state) {
+    if (state.saturated) {
+      if (state.omitted < MAX_SAFE_COUNT) state.omitted++;
+      if (saturatedProbeOmissions < MAX_SAFE_COUNT) saturatedProbeOmissions++;
+      return -2;
+    }
+    const calls = ++state.calls;
+    if (calls > siteObservationLimit) {
+      state.saturated = true;
+      return -1;
+    }
+    return 1;
+  }
+
+  function increment(map, key, weight) {
+    const existing = safeMapGet(map, key);
+    if (existing === undefined && safeMapSize(map) >= MAX_COUNTER_KEYS) {
+      recordOmission(safeStringSlice(key, 0, safeStringIndexOf(key, '|')), 'counterObservations');
+      return;
+    }
+    safeMapSet(map, key, (existing ?? 0) + weight);
+  }
+
+  function observeState(state, value, fields) {
+    if (!enabled) return value;
+    try {
+      const site = state.metadata.probeKey;
+      const action = actionForProbe();
+      if (action?.suppressed) return value;
+      const probeKind = state.metadata.probeKind;
+      const executionValue = action && (probeKind === 'parameter' || probeKind === 'return');
+      const weight = sampleWeight(state);
+      if (weight === -2) {
+        if (executionValue) {
+          const skippedEvents = value !== null && typeof value === 'object' && !safeArrayIsArray(value)
+            ? 1 + safeMathMin(fields.length, 48)
+            : 1;
+          omitExecutionEvents(action, skippedEvents);
+        }
+        return value;
+      }
+      if (weight < 0) {
+        if (weight === -1) increment(currentShape, `${site}|__saturated__|info`, 1);
+        if (executionValue) {
+          const skippedEvents = value !== null && typeof value === 'object' && !safeArrayIsArray(value)
+            ? 1 + safeMathMin(fields.length, 48)
+            : 1;
+          omitExecutionEvents(action, skippedEvents);
+        }
+        return value;
+      }
+      const fieldEventCount = safeArrayIsArray(fields) && value !== null &&
+        typeof value === 'object' && !safeArrayIsArray(value)
+        ? safeMathMin(fields.length, 48)
+        : 0;
+      const correlated = executionValue && !action.truncated;
+      if (executionValue && action.truncated) omitExecutionEvents(action, 1 + fieldEventCount);
+      if (weight > 0) {
+        const selfOutcome = value === null ? 'null' : value === undefined ? 'undefined' : 'ok';
+        increment(currentShape, `${site}|__self__|${selfOutcome}`, weight);
+        increment(currentShape, `${site}|__self__|shape:${valueShape(value)}`, weight);
+      }
+      if (correlated && probeKind === 'parameter') {
+        addExecutionEvent(site, 'input', 'whole-value', `shape:${valueShape(value)}`);
+      } else if (correlated && probeKind === 'return') {
+        addExecutionEvent(site, 'output', 'whole-value', `shape:${valueShape(value)}`);
+      }
+
+      if (safeArrayIsArray(fields) && value !== null && typeof value === 'object' && !safeArrayIsArray(value)) {
+        const proxyValue = safeIsProxy(value);
+        for (let fieldIndex = 0; fieldIndex < fields.length && fieldIndex < 48; fieldIndex++) {
+          const field = fields[fieldIndex];
+          // Manifest loading already validates the static field list. Avoid
+          // mutable RegExp/String prototype calls in this hot probe path.
+          if (typeof field !== 'string') continue;
+          const ordinal = fieldIndex + 1;
+          const fieldScope = `named-field-${ordinal < 10 ? `0${ordinal}` : ordinal}`;
+          if (proxyValue) {
+            if (weight > 0) increment(currentShape, `${site}|${field}|uninspectable`, weight);
+            if (correlated) {
+              addExecutionEvent(site, probeKind === 'parameter' ? 'input' : 'output', fieldScope, 'uninspectable');
+            }
+            continue;
+          }
+          let descriptor;
+          try {
+            descriptor = safeGetOwnPropertyDescriptor(value, field);
+          } catch {
+            if (weight > 0) increment(currentShape, `${site}|${field}|uninspectable`, weight);
+            if (correlated) {
+              addExecutionEvent(site, probeKind === 'parameter' ? 'input' : 'output', fieldScope, 'uninspectable');
+            }
+            continue;
+          }
+          if (!descriptor) {
+            if (weight > 0) increment(currentShape, `${site}|${field}|absent`, weight);
+            if (correlated) {
+              addExecutionEvent(site, probeKind === 'parameter' ? 'input' : 'output', fieldScope, 'absent');
+            }
+          } else if (!safeHasOwn(descriptor, 'value')) {
+            if (weight > 0) increment(currentShape, `${site}|${field}|accessor`, weight);
+            if (correlated) {
+              addExecutionEvent(site, probeKind === 'parameter' ? 'input' : 'output', fieldScope, 'accessor');
+            }
+          } else {
+            const fieldValue = descriptor.value;
+            const outcome = fieldValue === null ? 'null' : fieldValue === undefined ? 'undefined' : 'ok';
+            if (weight > 0) {
+              increment(currentShape, `${site}|${field}|${outcome}`, weight);
+              increment(currentShape, `${site}|${field}|shape:${valueShape(fieldValue)}`, weight);
+            }
+            if (correlated) {
+              addExecutionEvent(
+                site,
+                probeKind === 'parameter' ? 'input' : 'output',
+                fieldScope,
+                `shape:${valueShape(fieldValue)}`,
+              );
+            }
+          }
+        }
+      }
+    } catch (error) {
+      // A hostile Proxy or exotic object must never affect the host app.
+      debug('value probe failed open', error);
+    }
+    return value;
+  }
+
+  function observe(site, value, fields) {
+    const state = safeMapGet(probeStates, site);
+    return state ? observeState(state, value, fields) : value;
+  }
+
+  function branchState(state, value) {
+    if (!enabled) return value;
+    try {
+      const site = state.metadata.probeKey;
+      const action = actionForProbe();
+      if (action?.suppressed) return value;
+      const weight = sampleWeight(state);
+      if (weight === -2) {
+        omitExecutionEvents(action);
+        return value;
+      }
+      if (weight < 0) {
+        if (weight === -1) increment(currentBranch, `${site}|S`, 1);
+        omitExecutionEvents(action);
+      }
+      else if (weight > 0) {
+        const outcome = value ? 'T' : 'F';
+        increment(currentBranch, `${site}|${outcome}`, weight);
+        if (action?.truncated) omitExecutionEvents(action);
+        else if (action) addExecutionEvent(site, 'branch', 'branch-result', outcome);
+      }
+    } catch (error) {
+      debug('branch probe failed open', error);
+    }
+    return value;
+  }
+
+  function branch(site, value) {
+    const state = safeMapGet(probeStates, site);
+    return state ? branchState(state, value) : value;
+  }
+
+  function thrownState(state, value) {
+    if (!enabled) return value;
+    try {
+      const site = state.metadata.probeKey;
+      const action = actionForProbe();
+      if (action?.suppressed) return value;
+      const weight = sampleWeight(state);
+      if (weight === -2) {
+        omitExecutionEvents(action);
+        return value;
+      }
+      if (weight < 0) {
+        if (weight === -1) increment(currentShape, `${site}|__saturated__|info`, 1);
+        omitExecutionEvents(action);
+      } else if (action?.truncated) omitExecutionEvents(action);
+      else if (action) addExecutionEvent(site, 'error', 'thrown-value', `error:${errorClass(value)}`);
+    } catch (error) {
+      debug('throw probe failed open', error);
+    }
+    return value;
+  }
+
+  function thrown(site, value) {
+    const state = safeMapGet(probeStates, site);
+    return state ? thrownState(state, value) : value;
+  }
+
+  function makePending(reason) {
+    if (pending || pendingQueue.length > 0 || (safeMapSize(currentShape) === 0 &&
+      safeMapSize(currentBranch) === 0 && safeMapSize(currentExecutions) === 0 &&
+      omittedExecutionFamilyObservations === 0 && sampledActions === 0 && unsampledActions === 0 &&
+      safeMapSize(currentOmissions) === 0 && saturatedProbeOmissions === 0)) return;
+    const shape = objectFromMap(currentShape);
+    const branchCounters = objectFromMap(currentBranch);
+    currentShape = new SafeMap();
+    currentBranch = new SafeMap();
+    const executions = safeArraySort(
+      mapValuesArray(currentExecutions),
+      (left, right) => compareStrings(left.familyId, right.familyId),
+    );
+    currentExecutions = new SafeMap();
+    currentExecutionBytes = 0;
+    const executionOmissions = {
+      sampledActions,
+      unsampledActions,
+      omittedFamilyObservations: omittedExecutionFamilyObservations,
+    };
+    sampledActions = 0;
+    unsampledActions = 0;
+    omittedExecutionFamilyObservations = 0;
+    if (saturatedProbeOmissions > 0) {
+      const countEntries = mapEntriesArray(probeStates);
+      for (let index = 0; index < countEntries.length; index++) {
+        const site = countEntries[index][0];
+        const state = countEntries[index][1];
+        if (!state || state.omitted <= 0) continue;
+        const current = safeMapGet(currentOmissions, site) || {
+          counterObservations: 0,
+          probeObservations: 0,
+        };
+        current.probeObservations = safeMathMin(
+          MAX_SAFE_COUNT,
+          current.probeObservations + state.omitted,
+        );
+        safeMapSet(currentOmissions, site, current);
+        state.omitted = 0;
+      }
+      saturatedProbeOmissions = 0;
+    }
+    const omittedEntries = safeArraySort(
+      mapEntriesArray(currentOmissions),
+      (leftEntry, rightEntry) => compareStrings(leftEntry[0], rightEntry[0]),
+    );
+    const omittedSites = safeArrayMap(omittedEntries, entry => ({
+      probeKey: entry[0],
+      counterObservations: entry[1].counterObservations,
+      probeObservations: entry[1].probeObservations,
+    }));
+    currentOmissions = new SafeMap();
+    const counterGroups = new SafeMap();
+    const groupFor = (probeKey) => {
+      let group = safeMapGet(counterGroups, probeKey);
+      if (!group) {
+        group = { probeKey, shape: [], branch: [], omission: null };
+        safeMapSet(counterGroups, probeKey, group);
+      }
+      return group;
+    };
+    const shapeEntries = safeObjectEntries(shape);
+    for (let index = 0; index < shapeEntries.length; index++) {
+      const entry = shapeEntries[index];
+      safeArrayPush(groupFor(safeStringSlice(entry[0], 0, safeStringIndexOf(entry[0], '|'))).shape, entry);
+    }
+    const branchEntries = safeObjectEntries(branchCounters);
+    for (let index = 0; index < branchEntries.length; index++) {
+      const entry = branchEntries[index];
+      safeArrayPush(groupFor(safeStringSlice(entry[0], 0, safeStringIndexOf(entry[0], '|'))).branch, entry);
+    }
+    for (let index = 0; index < omittedSites.length; index++) {
+      const omission = omittedSites[index];
+      groupFor(omission.probeKey).omission = omission;
+    }
+
+    const packUnits = (units) => {
+      const chunks = [];
+      let current = [];
+      let bytes = 0;
+      for (let unitIndex = 0; unitIndex < units.length; unitIndex++) {
+        const unit = units[unitIndex];
+        let unitBytes = safeBufferByteLength(safeJsonStringify(unit), 'utf8') + 2_048;
+        if (unit.type === 'counter') {
+          unitBytes += safeBufferByteLength(safeJsonStringify(safeMapGet(sitesByProbe, unit.group.probeKey)), 'utf8');
+        } else if (unit.type === 'execution') {
+          unitBytes += safeArrayReduce(unit.unit.eventSites, (total, probeKey) =>
+            total + safeBufferByteLength(safeJsonStringify(safeMapGet(sitesByProbe, probeKey)), 'utf8'), 0);
+        }
+        if (current.length > 0 && bytes + unitBytes > PAYLOAD_CHUNK_BUDGET) {
+          safeArrayPush(chunks, current);
+          current = [];
+          bytes = 0;
+        }
+        safeArrayPush(current, unit);
+        bytes += unitBytes;
+      }
+      if (current.length > 0) safeArrayPush(chunks, current);
+      return chunks;
+    };
+
+    const executionUnits = safeArrayMap(executions, execution => {
+      const eventSiteSet = new SafeSet();
+      for (let eventIndex = 0; eventIndex < execution.events.length; eventIndex++) {
+        const event = execution.events[eventIndex];
+        const siteMetadata = safeMapGet(sitesById, event.siteId);
+        if (siteMetadata?.probeKey) safeSetAdd(eventSiteSet, siteMetadata.probeKey);
+      }
+      const eventSites = safeArraySort(setValuesArray(eventSiteSet), compareStrings);
+      return { execution, eventSites };
+    });
+    const counterUnits = safeArrayMap(
+      safeArraySort(mapValuesArray(counterGroups),
+        (left, right) => compareStrings(left.probeKey, right.probeKey)),
+      group => ({ type: 'counter', group }),
+    );
+    const projectedExecutionUnits = safeArrayMap(executionUnits, unit => ({ type: 'execution', unit }));
+    const unitsToPack = [];
+    for (let index = 0; index < counterUnits.length; index++) safeArrayPush(unitsToPack, counterUnits[index]);
+    for (let index = 0; index < projectedExecutionUnits.length; index++) {
+      safeArrayPush(unitsToPack, projectedExecutionUnits[index]);
+    }
+    const packed = packUnits(unitsToPack);
+    const chunkInputs = safeArrayMap(packed, units => ({
+      groups: safeArrayMap(safeArrayFilter(units, unit => unit.type === 'counter'), unit => unit.group),
+      executionUnits: safeArrayMap(safeArrayFilter(units, unit => unit.type === 'execution'), unit => unit.unit),
+    }));
+    if (chunkInputs.length === 0) safeArrayPush(chunkInputs, { groups: [], executionUnits: [] });
+    const observedAt = safeDateToISOString(new SafeDate());
+    const serialized = safeArrayMap(chunkInputs, (chunk, index) => {
+      const chunkShape = objectFromEntryArray(safeArrayFlatMap(chunk.groups, group => group.shape));
+      const chunkBranch = objectFromEntryArray(safeArrayFlatMap(chunk.groups, group => group.branch));
+      const chunkOmittedSites = safeArrayFilter(
+        safeArrayMap(chunk.groups, group => group.omission),
+        item => item !== null && item !== undefined,
+      );
+      const chunkOmissions = safeArrayReduce(chunkOmittedSites, (totals, item) => ({
+        counterObservations: totals.counterObservations + item.counterObservations,
+        probeObservations: totals.probeObservations + item.probeObservations,
+      }), { counterObservations: 0, probeObservations: 0 });
+      const chunkExecutions = safeArrayMap(chunk.executionUnits, unit => unit.execution);
+      const usedProbeKeys = new SafeSet();
+      for (let groupIndex = 0; groupIndex < chunk.groups.length; groupIndex++) {
+        safeSetAdd(usedProbeKeys, chunk.groups[groupIndex].probeKey);
+      }
+      for (let unitIndex = 0; unitIndex < chunk.executionUnits.length; unitIndex++) {
+        const unit = chunk.executionUnits[unitIndex];
+        for (let siteIndex = 0; siteIndex < unit.eventSites.length; siteIndex++) {
+          safeSetAdd(usedProbeKeys, unit.eventSites[siteIndex]);
+        }
+      }
+      const payload = {
+        v: 1,
+        samplerVersion: SAMPLER_VERSION,
+        buildId,
+        runId,
+        seq: sequence + index,
+        ts: observedAt,
+        reason: safeStringSlice(safeString(reason), 0, 256),
+        omissions: chunkOmissions,
+        omittedSites: chunkOmittedSites,
+        executionOmissions: index === 0 ? executionOmissions : {
+          sampledActions: 0,
+          unsampledActions: 0,
+          omittedFamilyObservations: 0,
+        },
+        sites: safeArrayMap(safeArraySort(setValuesArray(usedProbeKeys), compareStrings),
+          key => safeMapGet(sitesByProbe, key)),
+        shape: chunkShape,
+        branch: chunkBranch,
+        executions: chunkExecutions,
+        coverage: [],
+      };
+      const body = safeJsonStringify(payload);
+      if (safeBufferByteLength(body, 'utf8') > MAX_PAYLOAD_BYTES) {
+        throw new SafeError('bounded telemetry unit exceeded the upload byte limit');
+      }
+      return { payload, body };
+    });
+    pending = safeArrayShift(serialized) ?? null;
+    pendingQueue = serialized;
+  }
+
+  async function doFlush(reason) {
+    if (!enabled) return false;
+    try {
+      makePending(reason);
+    } catch (error) {
+      disable('payload construction failure', error);
+      return false;
+    }
+    if (!pending) return true;
+    try {
+      let uploaded = false;
+      while (pending) {
+      const response = await safeFetch(endpoint, {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${token}`,
+          'Content-Type': 'application/json',
+        },
+        body: pending.body,
+        signal: safeAbortTimeout(10_000),
+      });
+      if (!responseAccepted(response)) throw new SafeError(`ingestion returned HTTP ${responseStatus(response)}`);
+      pending = null;
+      sequence++;
+      uploaded = true;
+      pending = safeArrayShift(pendingQueue) ?? null;
+      }
+      consecutiveFailures = 0;
+      return true;
+    } catch (error) {
+      consecutiveFailures++;
+      debug(`flush failed; exact payload retained (${consecutiveFailures}/${MAX_CONSECUTIVE_FAILURES})`, error);
+      if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) disable('repeated flush failures', error);
+      return false;
+    }
+  }
+
+  const spoolDirectory = join(
+    tmpdir(),
+    `haystack-telemetry-${safeStringSlice(stableIdentity('owner', [endpoint, token, buildId]), 'owner-'.length)}`,
+  );
+
+  function spoolBody(body) {
+    try {
+      const bodyBytes = safeBufferByteLength(body, 'utf8');
+      if (bodyBytes > MAX_PAYLOAD_BYTES) {
+        debug('oversized crash payload was not spooled');
+        return;
+      }
+      mkdirSync(spoolDirectory, { recursive: true, mode: 0o700 });
+      const digest = sha256Hex(body);
+      const finalPath = join(spoolDirectory, `pending-${digest}.json`);
+      const pendingNames = safeArrayFilter(readdirSync(spoolDirectory),
+        name => safeRegExpTest(/^pending-[0-9a-f]{64}\.json$/, name));
+      const described = safeArrayMap(pendingNames, name => {
+          const path = join(spoolDirectory, name);
+          try {
+            const stats = statSync(path);
+            return { name, path, bytes: stats.size, modified: stats.mtimeMs };
+          } catch {
+            return null;
+          }
+        });
+      const existing = safeArraySort(
+        safeArrayFilter(described, item => item !== null && item !== undefined),
+        (left, right) => left.modified - right.modified || compareStrings(left.name, right.name),
+      );
+      let retainedBytes = safeArrayReduce(existing, (total, file) => total + file.bytes, 0);
+      const receiptPath = join(spoolDirectory, 'dropped.json');
+      let dropped = { chunks: 0, bytes: 0, payload: null };
+      try {
+        const parsed = safeJsonParse(readFileSync(receiptPath, 'utf8'));
+        if (safeNumberIsSafeInteger(parsed.chunks) && parsed.chunks >= 0 &&
+            safeNumberIsSafeInteger(parsed.bytes) && parsed.bytes >= 0 &&
+            (parsed.payload === null || typeof parsed.payload === 'object')) dropped = parsed;
+      } catch {
+        // No prior eviction receipt is the expected case.
+      }
+      while (existing.length >= MAX_SPOOL_FILES || retainedBytes + bodyBytes > MAX_SPOOL_BYTES) {
+        const oldest = safeArrayShift(existing);
+        if (!oldest) break;
+        try {
+          unlinkSync(oldest.path);
+          retainedBytes -= oldest.bytes;
+          dropped.chunks++;
+          dropped.bytes += oldest.bytes;
+          dropped.payload = null;
+        } catch {
+          break;
+        }
+      }
+      if (retainedBytes + bodyBytes > MAX_SPOOL_BYTES) return;
+      if (dropped.chunks > 0) {
+        writeFileSync(receiptPath, safeJsonStringify(dropped), { encoding: 'utf8', mode: 0o600 });
+      }
+      const temporaryPath = join(spoolDirectory, `.pending-${process.pid}-${digest}.tmp`);
+      writeFileSync(temporaryPath, body, { encoding: 'utf8', mode: 0o600 });
+      renameSync(temporaryPath, finalPath);
+    } catch (error) {
+      debug('crash payload could not be spooled', error);
+    }
+  }
+
+  function spoolCurrent(reason) {
+    try {
+      if (pending) {
+        spoolBody(pending.body);
+        sequence = safeMathMax(sequence, pending.payload.seq + 1);
+        pending = null;
+      }
+      for (let index = 0; index < pendingQueue.length; index++) {
+        const queued = pendingQueue[index];
+        spoolBody(queued.body);
+        sequence = safeMathMax(sequence, queued.payload.seq + 1);
+      }
+      pendingQueue = [];
+      makePending(reason);
+      if (pending) {
+        spoolBody(pending.body);
+        for (let index = 0; index < pendingQueue.length; index++) spoolBody(pendingQueue[index].body);
+      }
+    } catch (error) {
+      debug('crash snapshot failed open', error);
+    }
+  }
+
+  async function replaySpooledPayloads() {
+    let files;
+    try {
+      files = safeArraySlice(
+        safeArraySort(
+          safeArrayFilter(readdirSync(spoolDirectory),
+            name => safeRegExpTest(/^pending-[0-9a-f]{64}\.json$/, name)),
+          compareStrings,
+        ),
+        0,
+        MAX_SPOOL_FILES,
+      );
+    } catch {
+      return;
+    }
+    const receiptPath = join(spoolDirectory, 'dropped.json');
+    try {
+      const dropped = safeJsonParse(readFileSync(receiptPath, 'utf8'));
+      if (safeNumberIsSafeInteger(dropped.chunks) && dropped.chunks > 0 &&
+          safeNumberIsSafeInteger(dropped.bytes) && dropped.bytes >= 0) {
+        const payload = dropped.payload && typeof dropped.payload === 'object'
+          ? dropped.payload
+          : {
+          v: 1,
+          samplerVersion: SAMPLER_VERSION,
+          buildId,
+          runId,
+          seq: sequence,
+          ts: safeDateToISOString(new SafeDate()),
+          reason: 'crash-spool-omission',
+          omissions: { counterObservations: 0, probeObservations: 0 },
+          omittedSites: [],
+          executionOmissions: {
+            sampledActions: 0,
+            unsampledActions: 0,
+            omittedFamilyObservations: 0,
+          },
+          deliveryOmissions: {
+            droppedCrashChunks: dropped.chunks,
+            droppedCrashBytes: dropped.bytes,
+          },
+          sites: [],
+          shape: {},
+          branch: {},
+          executions: [],
+          coverage: [],
+        };
+        // Reserve this identity before any asynchronous request. Normal and
+        // beforeExit flushes may run concurrently and must never reuse it.
+        if (payload.runId === runId && safeNumberIsSafeInteger(payload.seq)) {
+          sequence = safeMathMax(sequence, payload.seq + 1);
+        }
+        if (!dropped.payload) {
+          const persisted = { chunks: dropped.chunks, bytes: dropped.bytes, payload };
+          const temporaryPath = join(spoolDirectory, `.dropped-${process.pid}.tmp`);
+          writeFileSync(temporaryPath, safeJsonStringify(persisted), { encoding: 'utf8', mode: 0o600 });
+          renameSync(temporaryPath, receiptPath);
+        }
+        const response = await safeFetch(endpoint, {
+          method: 'POST',
+          headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
+          body: safeJsonStringify(payload),
+          signal: safeAbortTimeout(10_000),
+        });
+        if (!responseAccepted(response)) return;
+        // The receiver accepted this exact omission count. A retry would add
+        // the same loss again under a new process run, so acknowledge it now.
+        unlinkSync(receiptPath);
+      }
+    } catch (error) {
+      if (error?.code !== 'ENOENT') debug('crash spool omission replay failed', error);
+    }
+    for (let index = 0; index < files.length; index++) {
+      const name = files[index];
+      const filePath = join(spoolDirectory, name);
+      try {
+        const body = readFileSync(filePath, 'utf8');
+        if (safeBufferByteLength(body, 'utf8') > MAX_PAYLOAD_BYTES) {
+          unlinkSync(filePath);
+          continue;
+        }
+        const response = await safeFetch(endpoint, {
+          method: 'POST',
+          headers: {
+            Authorization: `Bearer ${token}`,
+            'Content-Type': 'application/json',
+          },
+          body,
+          signal: safeAbortTimeout(10_000),
+        });
+        if (!responseAccepted(response)) break;
+        unlinkSync(filePath);
+      } catch (error) {
+        debug('spooled crash payload replay failed', error);
+        break;
+      }
+    }
+  }
+
+  function flush(reason = 'manual') {
+    if (flushInFlight) return flushInFlight;
+    if (!processAction.suppressed && reason !== 'interval' && reason !== 'http-finish') {
+      finalizeAction(processAction, processAction.outcome || (process.exitCode ? 'error' : 'success'));
+      if (reason !== 'before-exit' && reason !== 'process-exit' &&
+          reason !== 'uncaught-exception' && reason !== 'unhandled-rejection') {
+        continueProcessAction();
+      }
+    }
+    flushInFlight = safePromiseFinally(doFlush(reason), () => {
+      flushInFlight = null;
+    });
+    return flushInFlight;
+  }
+
+  const timer = setInterval(() => { void flush('interval'); }, flushIntervalMs);
+  timer.unref();
+  void replaySpooledPayloads();
+  process.on('uncaughtExceptionMonitor', (error) => {
+    const action = actionForProbe() || processAction;
+    if (action && !action.suppressed && !action.finalized) {
+      action.outcome = 'error';
+      action.terminalError = `error:${errorClass(error)}`;
+      finalizeAction(action, 'error');
+    }
+    spoolCurrent('uncaught-exception');
+  });
+  process.once('exit', (code) => {
+    if (!processAction.suppressed && !processAction.finalized) {
+      processAction.terminalError = code ? 'error:generic' : processAction.terminalError;
+      finalizeAction(processAction, code ? 'error' : processAction.outcome || 'success');
+    }
+    if (pending || pendingQueue.length || safeMapSize(currentExecutions) ||
+        safeMapSize(currentShape) || safeMapSize(currentBranch)) {
+      spoolCurrent('process-exit');
+    }
+  });
+  process.once('beforeExit', () => {
+    if (beforeExitStarted) return;
+    beforeExitStarted = true;
+    if (!processAction.suppressed) {
+      finalizeAction(processAction, processAction.outcome || (process.exitCode ? 'error' : 'success'));
+    }
+    void flush('before-exit');
+  });
+
+  const control = Object.freeze({
+    enabled: true,
+    runtimeVersion: RUNTIME_VERSION,
+    buildId,
+    runId,
+    flush,
+    selectProbe(name) {
+      if (!enabled || processAction.suppressed) return passThrough;
+      if (name === '__hstValue') return observe;
+      if (name === '__hstBranch') return branch;
+      if (name === '__hstThrow') return thrown;
+      return null;
+    },
+    selectSiteProbe(name, site) {
+      if (!enabled || processAction.suppressed) return null;
+      const state = safeMapGet(probeStates, site);
+      if (!state) return null;
+      if (name === '__hstValue') {
+        const fields = state.metadata.allowedFields;
+        return (value) => {
+          if (!enabled) return value;
+          if (state.saturated) {
+            const action = actionForProbe();
+            if (action?.suppressed) return value;
+            const executionValue = state.metadata.probeKind === 'parameter' ||
+              state.metadata.probeKind === 'return';
+            if (state.omitted < MAX_SAFE_COUNT) state.omitted++;
+            if (saturatedProbeOmissions < MAX_SAFE_COUNT) saturatedProbeOmissions++;
+            if (executionValue) {
+              const skippedEvents = value !== null && typeof value === 'object' && !safeArrayIsArray(value)
+                ? 1 + safeMathMin(fields.length, 48)
+                : 1;
+              omitExecutionEvents(action, skippedEvents);
+            }
+            return value;
+          }
+          return observeState(state, value, fields);
+        };
+      }
+      if (name === '__hstBranch') return (value) => {
+        if (!enabled) return value;
+        if (state.saturated) {
+          const action = actionForProbe();
+          if (action?.suppressed) return value;
+          if (state.omitted < MAX_SAFE_COUNT) state.omitted++;
+          if (saturatedProbeOmissions < MAX_SAFE_COUNT) saturatedProbeOmissions++;
+          omitExecutionEvents(action);
+          return value;
+        }
+        return branchState(state, value);
+      };
+      if (name === '__hstThrow') return (value) => {
+        if (!enabled) return value;
+        if (state.saturated) {
+          const action = actionForProbe();
+          if (action?.suppressed) return value;
+          if (state.omitted < MAX_SAFE_COUNT) state.omitted++;
+          if (saturatedProbeOmissions < MAX_SAFE_COUNT) saturatedProbeOmissions++;
+          omitExecutionEvents(action);
+          return value;
+        }
+        return thrownState(state, value);
+      };
+      return null;
+    },
+    status() {
+      return {
+        enabled,
+        sequence,
+        pending: pending !== null || pendingQueue.length > 0,
+        shapeKeys: safeMapSize(currentShape),
+        branchKeys: safeMapSize(currentBranch),
+        executionFamilies: safeMapSize(currentExecutions),
+      };
+    },
+  });
+  activeControl = control;
+  Object.defineProperty(processHost, CONTROL_CHANNEL, {
+    configurable: false,
+    enumerable: false,
+    writable: false,
+    value: control,
+  });
+  if (!(CONTROL_GLOBAL in globalThis)) {
+    Object.defineProperty(globalThis, CONTROL_GLOBAL, {
+      configurable: false,
+      enumerable: false,
+      writable: false,
+      value: control,
+    });
+  }
+  debug(`enabled for build ${buildId}`);
+  return control;
+}
+
+function install(options = {}) {
+  try {
+    return installRuntime(options);
+  } catch (error) {
+    // Bootstrap is injected into the application entry point, so this final
+    // boundary must catch every setup failure. Telemetry is never allowed to
+    // prevent the host application from starting.
+    debug('installation failed open', error);
+    return { enabled: false, reason: 'installation-failed' };
+  }
+}
+
+const publicRuntime = Object.freeze({ install, selectProbe, safeSelectProbe, safeSelectSiteProbe });
+// Keep the exported capability immutable. The generated CommonJS entry locks
+// its cache slot after genuine evaluation; the ESM wrapper evaluates this
+// source outside CommonJS's public cache.
+Object.defineProperty(module, 'exports', {
+  configurable: false,
+  enumerable: true,
+  writable: false,
+  value: publicRuntime,
+});
+install();