@autter/runtime-node 1.6.0 → 1.7.0

package/dist/{chunk-OY2HTUWY.js → chunk-LG52CW3V.js}

@@ -119,6 +119,43 @@ var compat_manifest_default = {
       ingester: "1.6.0",
       migrations: [],
       sdks: { "@autter/runtime-browser": "1.6.0", "@autter/runtime-next": "1.6.0", "@autter/runtime-node": "1.6.0" }
+    },
+    {
+      id: "sourcemap_upload_keys",
+      title: "Upload-only keys for source maps (autter_rtu_)",
+      ingester: "1.7.0",
+      migrations: [],
+      route: "/v1/sourcemaps",
+      sdks: {}
+    },
+    {
+      id: "source_map_verify",
+      title: "Source map check by debug id (autter-runtime sourcemaps verify)",
+      ingester: "1.7.0",
+      migrations: ["0017-source-maps-debug-id"],
+      route: "/v1/sourcemaps/check",
+      sdks: {}
+    },
+    {
+      id: "ingest_drop_counts",
+      title: "Rejected and dropped records per repository",
+      ingester: "1.8.0",
+      migrations: ["0018-runtime-ingest-drops"],
+      sdks: {}
+    },
+    {
+      id: "telemetry_sender_via",
+      title: "How each service's telemetry arrives (SDK, OpenTelemetry Collector or browser relay)",
+      ingester: "1.8.0",
+      migrations: ["0019-sdk-versions-via"],
+      sdks: {}
+    },
+    {
+      id: "frame_resolution_counts",
+      title: "Resolved and unresolved browser frames per occurrence",
+      ingester: "1.8.0",
+      migrations: ["0020-occurrence-frame-resolution"],
+      sdks: {}
     }
   ]
 };
@@ -464,7 +501,7 @@ import { request as httpsRequest } from "https";
 // package.json
 var package_default = {
   name: "@autter/runtime-node",
-  version: "1.6.0",
+  version: "1.7.0",
   description: "Autter Runtime for Node.js: request wide events, coded errors, operation logging, same-origin browser relay and a curated OpenTelemetry server tracker",
   license: "MIT",
   type: "module",
@@ -539,6 +576,55 @@ var package_default = {
   ]
 };
 
+// src/shared.ts
+var SHARED_STATE_KEY = /* @__PURE__ */ Symbol.for("@autter/runtime-node");
+var SHARED_STATE_LAYOUT = 1;
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+var VERSION = package_default.version;
+function resolveShared() {
+  const fresh = { v: SHARED_STATE_LAYOUT, sdk: VERSION };
+  const host = globalThis;
+  let existing;
+  try {
+    existing = host[SHARED_STATE_KEY];
+    if (existing === void 0) {
+      Object.defineProperty(host, SHARED_STATE_KEY, {
+        value: fresh,
+        configurable: true,
+        enumerable: false,
+        writable: false
+      });
+      return fresh;
+    }
+  } catch {
+    return fresh;
+  }
+  if (isObject(existing) && existing.v === SHARED_STATE_LAYOUT) return existing;
+  debugLog(
+    `another copy of @autter/runtime-node uses shared state layout ${String(isObject(existing) ? existing.v : typeof existing)}; this copy (${VERSION}, layout ${SHARED_STATE_LAYOUT}) keeps its own state`
+  );
+  return fresh;
+}
+var shared = resolveShared();
+function sharedSlot(name, init) {
+  const fresh = init();
+  try {
+    const existing = shared[name];
+    if (!isObject(existing)) {
+      shared[name] = fresh;
+      return fresh;
+    }
+    for (const [key, value] of Object.entries(fresh)) {
+      if (existing[key] === void 0) existing[key] = value;
+    }
+    return existing;
+  } catch {
+    return fresh;
+  }
+}
+
 // src/compat.ts
 var SDK_IDENTITY = {
   name: "@autter/runtime-node",
@@ -631,7 +717,7 @@ function envDisabled() {
   return value === "0" || value === "false" || value === "off";
 }
 var defaultWarn = (message) => console.warn(`[autter-runtime] ${message}`);
-var state = freshState(null, false);
+var compat = sharedSlot("compat", () => ({ state: freshState(null, false) }));
 function freshState(endpoint, enabled, sdk = SDK_IDENTITY, warn = defaultWarn) {
   return {
     endpoint,
@@ -646,7 +732,7 @@ function freshState(endpoint, enabled, sdk = SDK_IDENTITY, warn = defaultWarn) {
   };
 }
 function configureCompatCheck(options) {
-  state = freshState(
+  compat.state = freshState(
     options.endpoint.replace(/\/$/, ""),
     options.enabled !== false && !envDisabled(),
     options.sdk ?? SDK_IDENTITY,
@@ -654,21 +740,21 @@ function configureCompatCheck(options) {
   );
 }
 function ensureCompatConfigured(endpoint) {
-  if (state.endpoint === null && !envDisabled()) {
-    state = freshState(endpoint.replace(/\/$/, ""), true);
+  if (compat.state.endpoint === null && !envDisabled()) {
+    compat.state = freshState(endpoint.replace(/\/$/, ""), true);
   }
 }
 function noteCompatFeature(id) {
   try {
-    if (!state.enabled || state.features.has(id) || !featureById(id)) return;
-    state.features.add(id);
-    if (state.info) {
+    if (!compat.state.enabled || compat.state.features.has(id) || !featureById(id)) return;
+    compat.state.features.add(id);
+    if (compat.state.info) {
       evaluateAndWarn();
       return;
     }
-    if (state.started) return;
-    state.started = true;
-    const current = state;
+    if (compat.state.started) return;
+    compat.state.started = true;
+    const current = compat.state;
     setTimeout(() => void runCheck(current), 0).unref();
   } catch {
   }
@@ -679,7 +765,7 @@ async function runCheck(current) {
     const { info, error } = await fetchIngesterCompat(current.endpoint, {
       probeRoutes: routesFor(current.features)
     });
-    if (state !== current) return;
+    if (compat.state !== current) return;
     if (!info) {
       debugLog(`compat check skipped: ${error ?? "ingester version unknown"}`);
       return;
@@ -703,8 +789,8 @@ function routesFor(features) {
   return routes;
 }
 function mergeInfo(next) {
-  const prev = state.info;
-  state.info = {
+  const prev = compat.state.info;
+  compat.state.info = {
     version: next.version ?? prev?.version ?? null,
     ...next.legacy || prev?.legacy ? { legacy: true } : {},
     ...next.schema ?? prev?.schema ? { schema: next.schema ?? prev?.schema } : {},
@@ -712,17 +798,17 @@ function mergeInfo(next) {
   };
 }
 function evaluateAndWarn() {
-  const info = state.info;
+  const info = compat.state.info;
   if (!info) return;
-  if (info.version === null && state.endpoint) {
-    const unprobed = routesFor(state.features).filter(
-      (route) => info.routes?.[route] === void 0 && !state.pendingProbes.has(route)
+  if (info.version === null && compat.state.endpoint) {
+    const unprobed = routesFor(compat.state.features).filter(
+      (route) => info.routes?.[route] === void 0 && !compat.state.pendingProbes.has(route)
     );
     if (unprobed.length) {
-      const current = state;
+      const current = compat.state;
       for (const route of unprobed) current.pendingProbes.add(route);
       void Promise.all(unprobed.map((route) => probeRoute(current.endpoint, route, {}).then((exists) => [route, exists]))).then((results) => {
-        if (state !== current) return;
+        if (compat.state !== current) return;
         const routes = {};
         for (const [route, exists] of results) if (exists !== null) routes[route] = exists;
         mergeInfo({ version: null, legacy: true, routes });
@@ -731,31 +817,31 @@ function evaluateAndWarn() {
       });
     }
   }
-  for (const issue of evaluateCompat({ features: state.features, ingester: info })) {
+  for (const issue of evaluateCompat({ features: compat.state.features, ingester: info })) {
     warnOnce(issue);
   }
 }
 function warnOnce(issue) {
   const key = `${issue.feature}:${issue.kind}`;
-  if (state.warned.has(key)) return;
-  state.warned.add(key);
+  if (compat.state.warned.has(key)) return;
+  compat.state.warned.add(key);
   try {
-    state.warn(issue.message);
+    compat.state.warn(issue.message);
   } catch {
   }
 }
 function observeIngesterResponse(response) {
   try {
-    if (!state.enabled) return;
+    if (!compat.state.enabled) return;
     const fromHeader = headerInfo(response.headers);
     if (fromHeader) {
-      if (state.info?.version !== fromHeader.version) {
+      if (compat.state.info?.version !== fromHeader.version) {
         mergeInfo(fromHeader);
         evaluateAndWarn();
       }
       return;
     }
-    if (response.status === 404 && response.route && !state.info?.version) {
+    if (response.status === 404 && response.route && !compat.state.info?.version) {
       mergeInfo({ version: null, legacy: true, routes: { [response.route]: false } });
       evaluateAndWarn();
     }
@@ -764,16 +850,16 @@ function observeIngesterResponse(response) {
 }
 function noteRelayRejection(eventTypes, status, headers) {
   try {
-    if (!state.enabled || status !== 400 || headerInfo(headers)) return [];
+    if (!compat.state.enabled || status !== 400 || headerInfo(headers)) return [];
     const named = [];
     for (const id of featuresForBrowserEvents(eventTypes)) {
       const feature = featureById(id);
       const key = `${id}:relay_rejected`;
-      if (state.warned.has(key)) continue;
-      state.warned.add(key);
+      if (compat.state.warned.has(key)) continue;
+      compat.state.warned.add(key);
       named.push(id);
       try {
-        state.warn(
+        compat.state.warn(
           `The ingester rejected a browser batch containing ${feature.title.toLowerCase()} events. ${feature.title} needs ingester >= ${feature.ingester}; yours is 1.4.0 or older (it predates version reporting), so those batches are dropped. ${ingesterUpgradeHint(COMPAT_MANIFEST)}`
         );
       } catch {
@@ -799,6 +885,7 @@ export {
   registerFlushTarget,
   unregisterFlushTargets,
   installAutterAutoFlush,
+  sharedSlot,
   SDK_IDENTITY,
   compatRequest,
   fetchIngesterCompat,

package/dist/{chunk-Y4T7SQMO.js → chunk-QUC6OUE7.js}

@@ -5,7 +5,7 @@ import {
   evaluateCompat,
   fetchIngesterCompat,
   versionAtLeast
-} from "./chunk-OY2HTUWY.js";
+} from "./chunk-LG52CW3V.js";
 
 // src/doctor.ts
 import { existsSync, readFileSync } from "fs";

package/dist/{chunk-UKYTXZOQ.cjs → chunk-RV4MJNM2.cjs}

@@ -1,7 +1,8 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
 
 
-var _chunkARN26OK6cjs = require('./chunk-ARN26OK6.cjs');
+
+var _chunkGYTQLITWcjs = require('./chunk-GYTQLITW.cjs');
 
 // ../runtime-core/dist/index.js
 var SENSITIVE_KEY_PATTERNS = [
@@ -993,7 +994,7 @@ var _crypto = require('crypto');
 
 var _fs = require('fs');
 var _path = require('path');
-var sinkStats = { dropped: 0 };
+var sinkStats = _chunkGYTQLITWcjs.sharedSlot.call(void 0, "sinks", () => ({ dropped: 0 }));
 function otlpSink(options = {}) {
   let context = null;
   let queue = [];
@@ -1069,7 +1070,7 @@ function otlpSink(options = {}) {
                 Math.max(1, Math.min(3e3, deadline - Date.now()))
               )
             });
-            _chunkARN26OK6cjs.observeIngesterResponse.call(void 0, { status: response.status, headers: response.headers, route: "/v1/logs" });
+            _chunkGYTQLITWcjs.observeIngesterResponse.call(void 0, { status: response.status, headers: response.headers, route: "/v1/logs" });
             if (!response.ok)
               throw new Error(`Runtime log export failed (${response.status})`);
             failure = void 0;
@@ -1119,7 +1120,7 @@ function otlpSink(options = {}) {
       }
       queue.push({ record, bytes });
       queueBytes += bytes;
-      _chunkARN26OK6cjs.noteCompatFeature.call(void 0, "operation_logging");
+      _chunkGYTQLITWcjs.noteCompatFeature.call(void 0, "operation_logging");
       scheduleFlush();
     },
     flush,
@@ -1362,18 +1363,22 @@ function memorySink() {
 }
 
 // src/logger.ts
-var local = new (0, _async_hooks.AsyncLocalStorage)();
-var config = null;
-var sinks = [];
-var extraSinks = /* @__PURE__ */ new Set();
+var shared = _chunkGYTQLITWcjs.sharedSlot.call(void 0, "logger", () => ({
+  local: new (0, _async_hooks.AsyncLocalStorage)(),
+  config: null,
+  sinks: [],
+  extraSinks: /* @__PURE__ */ new Set()
+}));
+var local = shared.local;
+var extraSinks = shared.extraSinks;
 var fallbackConsole = null;
 function redact(attributes) {
-  return _nullishCoalesce(_optionalChain([config, 'optionalAccess', _16 => _16.redact, 'call', _17 => _17(attributes)]), () => ( redactAttributes(attributes)));
+  return _nullishCoalesce(_optionalChain([shared, 'access', _16 => _16.config, 'optionalAccess', _17 => _17.redact, 'call', _18 => _18(attributes)]), () => ( redactAttributes(attributes)));
 }
 var safe = (attributes = {}) => boundContext(attributes, redact);
 var merge = (current, next) => mergeContext(current, next, redact);
 function activeSinks() {
-  if (config) return extraSinks.size ? [...sinks, ...extraSinks] : sinks;
+  if (shared.config) return extraSinks.size ? [...shared.sinks, ...extraSinks] : shared.sinks;
   if (extraSinks.size) return [...extraSinks];
   fallbackConsole ??= consoleSink();
   return [fallbackConsole];
@@ -1407,12 +1412,12 @@ function traceAttributes(state) {
 }
 function emit(level, message, attributes, extra = {}, options = {}) {
   const state = options.state !== void 0 ? _nullishCoalesce(options.state, () => ( void 0)) : local.getStore();
-  if (_optionalChain([state, 'optionalAccess', _18 => _18.sealed])) return;
+  if (_optionalChain([state, 'optionalAccess', _19 => _19.sealed])) return;
   const summary = extra["autter.event.type"] === "operation";
   if (!summary) recordLogBreadcrumb(level, message, attributes, state);
-  if (!summary && LEVEL_SEVERITY[level] < LEVEL_SEVERITY[_nullishCoalesce(_optionalChain([config, 'optionalAccess', _19 => _19.options, 'optionalAccess', _20 => _20.minLevel]), () => ( "debug"))])
+  if (!summary && LEVEL_SEVERITY[level] < LEVEL_SEVERITY[_nullishCoalesce(_optionalChain([shared, 'access', _20 => _20.config, 'optionalAccess', _21 => _21.options, 'optionalAccess', _22 => _22.minLevel]), () => ( "debug"))])
     return;
-  if (!summary && state && _optionalChain([config, 'optionalAccess', _21 => _21.options, 'optionalAccess', _22 => _22.inline]) !== false) {
+  if (!summary && state && _optionalChain([shared, 'access', _23 => _23.config, 'optionalAccess', _24 => _24.options, 'optionalAccess', _25 => _25.inline]) !== false) {
     const { "exception.stacktrace": _stack, ...inlineAttrs } = userContext(
       attributes,
       redact
@@ -1420,8 +1425,8 @@ function emit(level, message, attributes, extra = {}, options = {}) {
     appendInlineLog(state.inline, level, message, inlineAttrs, redact);
     if (level === "debug" || level === "info") return;
   }
-  const span = _nullishCoalesce(options.span, () => ( _optionalChain([_api.trace, 'access', _23 => _23.getActiveSpan, 'call', _24 => _24(), 'optionalAccess', _25 => _25.spanContext, 'call', _26 => _26()])));
-  const user = merge(_nullishCoalesce(_optionalChain([state, 'optionalAccess', _27 => _27.attributes]), () => ( {})), attributes);
+  const span = _nullishCoalesce(options.span, () => ( _optionalChain([_api.trace, 'access', _26 => _26.getActiveSpan, 'call', _27 => _27(), 'optionalAccess', _28 => _28.spanContext, 'call', _29 => _29()])));
+  const user = merge(_nullishCoalesce(_optionalChain([state, 'optionalAccess', _30 => _30.attributes]), () => ( {})), attributes);
   const exceptions = Object.fromEntries(
     Object.entries(user).filter(([key]) => key.startsWith("exception."))
   );
@@ -1432,8 +1437,8 @@ function emit(level, message, attributes, extra = {}, options = {}) {
     ...operationAttributes(state),
     ...user
   };
-  const enrichers = _optionalChain([config, 'optionalAccess', _28 => _28.options, 'optionalAccess', _29 => _29.enrich]);
-  if (summary && state && _optionalChain([enrichers, 'optionalAccess', _30 => _30.length])) {
+  const enrichers = _optionalChain([shared, 'access', _31 => _31.config, 'optionalAccess', _32 => _32.options, 'optionalAccess', _33 => _33.enrich]);
+  if (summary && state && _optionalChain([enrichers, 'optionalAccess', _34 => _34.length])) {
     const event2 = { level, message, attributes: raw };
     for (const enrich of enrichers) {
       try {
@@ -1460,11 +1465,11 @@ function emit(level, message, attributes, extra = {}, options = {}) {
   }
 }
 function configureRuntimeLogger(next) {
-  config = next;
-  sinks = defaultSinks(next);
-  for (const sink of sinks) {
+  shared.config = next;
+  shared.sinks = defaultSinks(next);
+  for (const sink of shared.sinks) {
     try {
-      _optionalChain([sink, 'access', _31 => _31.start, 'optionalCall', _32 => _32({
+      _optionalChain([sink, 'access', _35 => _35.start, 'optionalCall', _36 => _36({
         endpoint: next.endpoint,
         apiKey: next.apiKey,
         service: next.service,
@@ -1477,14 +1482,14 @@ function configureRuntimeLogger(next) {
   }
 }
 function loggerConfigured() {
-  return config;
+  return shared.config;
 }
 function addRuntimeSink(sink) {
   extraSinks.add(sink);
   return () => extraSinks.delete(sink);
 }
 function notifyException(error, attributes = {}) {
-  if (!extraSinks.size && !sinks.some((sink) => sink.exception)) return;
+  if (!extraSinks.size && !shared.sinks.some((sink) => sink.exception)) return;
   const state = local.getStore();
   const record = {
     time: Date.now(),
@@ -1493,36 +1498,36 @@ function notifyException(error, attributes = {}) {
     type: isError(error) ? error.name : "Error",
     attributes: { ...attributes, ...errorAttributes(error) },
     ...state ? { operationId: state.id } : {},
-    ..._optionalChain([state, 'optionalAccess', _33 => _33.requestId]) ? { requestId: state.requestId } : {}
+    ..._optionalChain([state, 'optionalAccess', _37 => _37.requestId]) ? { requestId: state.requestId } : {}
   };
-  for (const sink of [...sinks, ...extraSinks]) {
+  for (const sink of [...shared.sinks, ...extraSinks]) {
     try {
-      _optionalChain([sink, 'access', _34 => _34.exception, 'optionalCall', _35 => _35(record)]);
+      _optionalChain([sink, 'access', _38 => _38.exception, 'optionalCall', _39 => _39(record)]);
     } catch (e19) {
     }
   }
 }
 function runtimeLogStats() {
   return {
-    buffered: sinks.reduce((sum, sink) => sum + (_nullishCoalesce(_optionalChain([sink, 'access', _36 => _36.buffered, 'optionalCall', _37 => _37()]), () => ( 0))), 0),
+    buffered: shared.sinks.reduce((sum, sink) => sum + (_nullishCoalesce(_optionalChain([sink, 'access', _40 => _40.buffered, 'optionalCall', _41 => _41()]), () => ( 0))), 0),
     dropped: sinkStats.dropped
   };
 }
 async function flushRuntimeLogs() {
-  if (!config) return;
+  if (!shared.config) return;
   const results = await Promise.allSettled(
-    sinks.map((sink) => Promise.resolve().then(() => _optionalChain([sink, 'access', _38 => _38.flush, 'optionalCall', _39 => _39()])))
+    shared.sinks.map((sink) => Promise.resolve().then(() => _optionalChain([sink, 'access', _42 => _42.flush, 'optionalCall', _43 => _43()])))
   );
   const failed = results.find((result) => result.status === "rejected");
   if (failed) throw failed.reason;
 }
 async function shutdownRuntimeLogger() {
-  const active = sinks;
+  const active = shared.sinks;
   const results = await Promise.allSettled(
-    active.map((sink) => Promise.resolve().then(() => _optionalChain([sink, 'access', _40 => _40.shutdown, 'optionalCall', _41 => _41()])))
+    active.map((sink) => Promise.resolve().then(() => _optionalChain([sink, 'access', _44 => _44.shutdown, 'optionalCall', _45 => _45()])))
   );
-  config = null;
-  sinks = [];
+  shared.config = null;
+  shared.sinks = [];
   const failed = results.find((result) => result.status === "rejected");
   if (failed) throw failed.reason;
 }
@@ -1560,7 +1565,7 @@ var runtimeLogger = createRuntimeLogger();
 function captureExceptionAsLog(error, attributes = {}) {
   const isErr = isError(error);
   const message = isErr ? error.message : String(error);
-  const stack = isErr && error.stack ? error.stack : _nullishCoalesce(_optionalChain([new Error(), 'access', _42 => _42.stack, 'optionalAccess', _43 => _43.split, 'call', _44 => _44("\n"), 'access', _45 => _45.filter, 'call', _46 => _46((line, i) => i === 0 || !/captureException/.test(line)), 'access', _47 => _47.join, 'call', _48 => _48("\n")]), () => ( ""));
+  const stack = isErr && error.stack ? error.stack : _nullishCoalesce(_optionalChain([new Error(), 'access', _46 => _46.stack, 'optionalAccess', _47 => _47.split, 'call', _48 => _48("\n"), 'access', _49 => _49.filter, 'call', _50 => _50((line, i) => i === 0 || !/captureException/.test(line)), 'access', _51 => _51.join, 'call', _52 => _52("\n")]), () => ( ""));
   noteOperationError(error);
   emit(
     "error",
@@ -1614,7 +1619,7 @@ function operationHandle(state) {
     setContext: (attrs) => {
       if (!state.sealed) {
         state.attributes = merge(state.attributes, attrs);
-        _optionalChain([_api.trace, 'access', _49 => _49.getActiveSpan, 'call', _50 => _50(), 'optionalAccess', _51 => _51.setAttributes, 'call', _52 => _52(traceAttributes(state))]);
+        _optionalChain([_api.trace, 'access', _53 => _53.getActiveSpan, 'call', _54 => _54(), 'optionalAccess', _55 => _55.setAttributes, 'call', _56 => _56(traceAttributes(state))]);
       }
     },
     outcome: (status, message) => setOutcome(state, status, message),
@@ -1674,7 +1679,7 @@ function emitSummary(state, options = {}) {
 }
 function reportExplicitFailure(state) {
   if (state.outcome === "failed" && state.explicitOutcome && !state.errorThrown)
-    _optionalChain([config, 'optionalAccess', _53 => _53.reportOutcome, 'call', _54 => _54(state.name, _nullishCoalesce(state.message, () => ( "Operation failed")), {
+    _optionalChain([shared, 'access', _57 => _57.config, 'optionalAccess', _58 => _58.reportOutcome, 'call', _59 => _59(state.name, _nullishCoalesce(state.message, () => ( "Operation failed")), {
       ...traceAttributes(state),
       "autter.outcome.stack": _nullishCoalesce(state.reportingStack, () => ( ""))
     })]);
@@ -1682,7 +1687,7 @@ function reportExplicitFailure(state) {
 function startOperation(name, fn, attributes, options, internal = {}) {
   const parent = _nullishCoalesce(internal.forkParent, () => ( local.getStore()));
   const carrier = options.from ? parseCarrier(options.from) : null;
-  const traceparent = _optionalChain([carrier, 'optionalAccess', _55 => _55.traceparent]) ? parseTraceparent(carrier.traceparent) : null;
+  const traceparent = _optionalChain([carrier, 'optionalAccess', _60 => _60.traceparent]) ? parseTraceparent(carrier.traceparent) : null;
   const linked = internal.forkParent !== void 0 || parent && !parent.sealed;
   const state = newState(
     name,
@@ -1694,7 +1699,7 @@ function startOperation(name, fn, attributes, options, internal = {}) {
       ...traceparent ? { parentTraceId: traceparent.traceId } : {}
     } : {
       ...linked && parent ? { parentId: parent.id, base: parent.attributes } : {},
-      ..._optionalChain([parent, 'optionalAccess', _56 => _56.requestId]) ? { requestId: parent.requestId } : {}
+      ..._optionalChain([parent, 'optionalAccess', _61 => _61.requestId]) ? { requestId: parent.requestId } : {}
     }
   );
   if (linked && parent) state.breadcrumbs = parent.breadcrumbs ??= new BreadcrumbTrail();
@@ -1708,16 +1713,16 @@ function startOperation(name, fn, attributes, options, internal = {}) {
       thrown = error;
       noteOperationError(error, true, state);
       rememberThrownBreadcrumbs(error, state);
-      _optionalChain([config, 'optionalAccess', _57 => _57.captureThrown, 'optionalCall', _58 => _58(error)]);
+      _optionalChain([shared, 'access', _62 => _62.config, 'optionalAccess', _63 => _63.captureThrown, 'optionalCall', _64 => _64(error)]);
       throw error;
     } finally {
-      _optionalChain([_api.trace, 'access', _59 => _59.getActiveSpan, 'call', _60 => _60(), 'optionalAccess', _61 => _61.setAttributes, 'call', _62 => _62({
+      _optionalChain([_api.trace, 'access', _65 => _65.getActiveSpan, 'call', _66 => _66(), 'optionalAccess', _67 => _67.setAttributes, 'call', _68 => _68({
         ...traceAttributes(state),
         "autter.operation.outcome": state.outcome,
         "autter.operation.kind": state.kind
       })]);
       if (state.outcome === "failed" && !thrown)
-        _optionalChain([config, 'optionalAccess', _63 => _63.reportOutcome, 'call', _64 => _64(
+        _optionalChain([shared, 'access', _69 => _69.config, 'optionalAccess', _70 => _70.reportOutcome, 'call', _71 => _71(
           state.name,
           _nullishCoalesce(state.message, () => ( "Operation failed")),
           {
@@ -1738,7 +1743,7 @@ function startOperation(name, fn, attributes, options, internal = {}) {
       }
     }
   ] : [];
-  const promise = _optionalChain([config, 'optionalAccess', _65 => _65.run]) ? config.run(state.name, run, traceAttributes(state), links) : run();
+  const promise = _optionalChain([shared, 'access', _72 => _72.config, 'optionalAccess', _73 => _73.run]) ? shared.config.run(state.name, run, traceAttributes(state), links) : run();
   if (!options.waitUntil) return promise;
   const waitUntil = options.waitUntil;
   return promise.finally(() => {
@@ -1761,7 +1766,7 @@ var runtimeContext = {
     const state = currentOperation();
     if (!state) return;
     state.attributes = merge(state.attributes, attributes);
-    _optionalChain([_api.trace, 'access', _66 => _66.getActiveSpan, 'call', _67 => _67(), 'optionalAccess', _68 => _68.setAttributes, 'call', _69 => _69(traceAttributes(state))]);
+    _optionalChain([_api.trace, 'access', _74 => _74.getActiveSpan, 'call', _75 => _75(), 'optionalAccess', _76 => _76.setAttributes, 'call', _77 => _77(traceAttributes(state))]);
   },
   /** Set the outcome explicitly (wins over status/thrown-error rules). */
   outcome(status, message) {
@@ -1784,11 +1789,11 @@ var runtimeContext = {
   },
   /** Current operation id. */
   get id() {
-    return _optionalChain([local, 'access', _70 => _70.getStore, 'call', _71 => _71(), 'optionalAccess', _72 => _72.id]);
+    return _optionalChain([local, 'access', _78 => _78.getStore, 'call', _79 => _79(), 'optionalAccess', _80 => _80.id]);
   },
   /** Current request id (inherited by child operations and forks). */
   get requestId() {
-    return _optionalChain([local, 'access', _73 => _73.getStore, 'call', _74 => _74(), 'optionalAccess', _75 => _75.requestId]);
+    return _optionalChain([local, 'access', _81 => _81.getStore, 'call', _82 => _82(), 'optionalAccess', _83 => _83.requestId]);
   },
   /**
    * Run `fn` as a child operation whose parent link is captured NOW, so it
@@ -1802,7 +1807,7 @@ var runtimeContext = {
   carrier() {
     const state = local.getStore();
     if (!state) return void 0;
-    const span = _optionalChain([_api.trace, 'access', _76 => _76.getActiveSpan, 'call', _77 => _77(), 'optionalAccess', _78 => _78.spanContext, 'call', _79 => _79()]);
+    const span = _optionalChain([_api.trace, 'access', _84 => _84.getActiveSpan, 'call', _85 => _85(), 'optionalAccess', _86 => _86.spanContext, 'call', _87 => _87()]);
     const traceparent = span ? formatTraceparent(span.traceId, span.spanId, (span.traceFlags & 1) === 1) : void 0;
     return createCarrier({
       op: state.id,
@@ -1815,18 +1820,23 @@ var runtimeContext = {
 // src/breadcrumbs.ts
 var INVALID_TRACE_ID = "00000000000000000000000000000000";
 var MAX_TRACE_TRAILS = 200;
-var byTrace = /* @__PURE__ */ new Map();
-var processTrail = new BreadcrumbTrail();
-var thrownTrails = /* @__PURE__ */ new WeakMap();
+var trails = _chunkGYTQLITWcjs.sharedSlot.call(void 0, "breadcrumbs", () => ({
+  byTrace: /* @__PURE__ */ new Map(),
+  process: new BreadcrumbTrail(),
+  thrown: /* @__PURE__ */ new WeakMap()
+}));
+var byTrace = trails.byTrace;
+var processTrail = trails.process;
+var thrownTrails = trails.thrown;
 function redact2(attributes) {
-  return _nullishCoalesce(_optionalChain([loggerConfigured, 'call', _80 => _80(), 'optionalAccess', _81 => _81.redact, 'call', _82 => _82(attributes)]), () => ( redactAttributes(attributes)));
+  return _nullishCoalesce(_optionalChain([loggerConfigured, 'call', _88 => _88(), 'optionalAccess', _89 => _89.redact, 'call', _90 => _90(attributes)]), () => ( redactAttributes(attributes)));
 }
 function trailFor(create, state = local.getStore()) {
   if (state) {
     if (!state.breadcrumbs && create) state.breadcrumbs = new BreadcrumbTrail();
     return state.breadcrumbs;
   }
-  const traceId = _optionalChain([_api.trace, 'access', _83 => _83.getActiveSpan, 'call', _84 => _84(), 'optionalAccess', _85 => _85.spanContext, 'call', _86 => _86(), 'access', _87 => _87.traceId]);
+  const traceId = _optionalChain([_api.trace, 'access', _91 => _91.getActiveSpan, 'call', _92 => _92(), 'optionalAccess', _93 => _93.spanContext, 'call', _94 => _94(), 'access', _95 => _95.traceId]);
   if (traceId && traceId !== INVALID_TRACE_ID) {
     let trail = byTrace.get(traceId);
     if (!trail && create) {
@@ -1845,8 +1855,8 @@ function addBreadcrumb(input) {
   try {
     const crumb = normalizeBreadcrumb(input, redact2);
     if (!crumb) return;
-    _optionalChain([trailFor, 'call', _88 => _88(true), 'optionalAccess', _89 => _89.add, 'call', _90 => _90(crumb)]);
-    _chunkARN26OK6cjs.noteCompatFeature.call(void 0, "breadcrumbs");
+    _optionalChain([trailFor, 'call', _96 => _96(true), 'optionalAccess', _97 => _97.add, 'call', _98 => _98(crumb)]);
+    _chunkGYTQLITWcjs.noteCompatFeature.call(void 0, "breadcrumbs");
   } catch (e21) {
   }
 }
@@ -1863,7 +1873,7 @@ function recordLogBreadcrumb(level, message, attributes, state) {
       }
     }
     const crumb = normalizeBreadcrumb({ type: "log", level, message, data }, redact2);
-    if (crumb) _optionalChain([trailFor, 'call', _91 => _91(true, state), 'optionalAccess', _92 => _92.add, 'call', _93 => _93(crumb)]);
+    if (crumb) _optionalChain([trailFor, 'call', _99 => _99(true, state), 'optionalAccess', _100 => _100.add, 'call', _101 => _101(crumb)]);
   } catch (e22) {
   }
 }
@@ -1881,7 +1891,7 @@ function breadcrumbEventAttributes(scrub, error) {
   try {
     const thrown = error !== null && typeof error === "object" ? thrownTrails.get(error) : void 0;
     const trail = _nullishCoalesce(thrown, () => ( trailFor(false)));
-    if (!_optionalChain([trail, 'optionalAccess', _94 => _94.size])) return {};
+    if (!_optionalChain([trail, 'optionalAccess', _102 => _102.size])) return {};
     const json = breadcrumbsAttribute(trail.list(), scrub, attributeBudget());
     return json ? { [BREADCRUMBS_ATTRIBUTE]: json } : {};
   } catch (e23) {