@nxtedition/nxt-undici 7.4.3 → 7.5.0

package/lib/interceptor/dns.js

@@ -1,6 +1,7 @@
 import net from 'node:net'
 import * as dns from 'node:dns'
 import { DecoratorHandler, getFastNow } from '../utils.js'
+import { traceWrite, traceSafe, traceErr, traceUrl } from '../trace.js'
 import xxhash from 'xxhash-wasm'
 
 let HASHER
@@ -119,8 +120,16 @@ export default () => (dispatch) => {
   function resolve(hostname, { ttl, negativeTTL, lookup }) {
     let promise = promises.get(hostname)
     if (!promise) {
+      // A synchronous lookup callback (custom resolvers answering from a local
+      // cache) runs inside the Promise executor, BEFORE the `promises.set`
+      // below — its cleanup delete would be a no-op and the settled promise
+      // would be retained forever, turning every later resolve() for the
+      // hostname (misses and pre-emptive refreshes alike) into a stale no-op.
+      // Track settlement so an already-settled promise is never registered.
+      let settled = false
       promise = new Promise((resolve) => {
         lookup(hostname, { all: true }, (err, records) => {
+          settled = true
           promises.delete(hostname)
 
           if (err) {
@@ -153,7 +162,9 @@ export default () => (dispatch) => {
           }
         })
       })
-      promises.set(hostname, promise)
+      if (!settled) {
+        promises.set(hostname, promise)
+      }
     }
     return promise
   }
@@ -190,10 +201,47 @@ export default () => (dispatch) => {
         // served from cache.
         const negative = negatives.get(hostname)
         if (negative != null && negative.expires >= now) {
+          // Cold path (fail-fast) — resolve the writer per emission, like
+          // response-retry's traceRetry.
+          const write = traceWrite(opts.trace)
+          if (write !== null) {
+            traceSafe(
+              write,
+              {
+                id: opts.id ?? null,
+                url: traceUrl(opts),
+                source: 'negative',
+                durationMs: 0,
+                records: null,
+                err: traceErr(negative.err),
+              },
+              'undici:dns',
+            )
+          }
           throw makeLookupError(negative.err)
         }
 
+        // Cold path (cache miss) — this request synchronously awaits the
+        // (possibly shared in-flight) resolution, so attribute the wait to it;
+        // concurrent awaiters each emit their own doc. The url tag is taken
+        // from the logical opts, before the origin is rewritten to the IP.
+        const write = traceWrite(opts.trace)
+        const started = write !== null ? performance.now() : 0
         const [err, val] = await resolve(hostname, { ttl, negativeTTL, lookup })
+        if (write !== null) {
+          traceSafe(
+            write,
+            {
+              id: opts.id ?? null,
+              url: traceUrl(opts),
+              source: 'miss',
+              durationMs: Math.round(performance.now() - started),
+              records: err ? null : val.length,
+              err: err ? traceErr(err) : null,
+            },
+            'undici:dns',
+          )
+        }
         if (err) {
           throw makeLookupError(err)
         }
@@ -242,7 +290,35 @@ export default () => (dispatch) => {
       // refreshed records land in cache for the next request, smoothing
       // out DNS lookup latency. `resolve()` dedupes via `promises`.
       if (records.some((x) => x.expires < now + ttl / 2)) {
-        resolve(hostname, { ttl, negativeTTL, lookup })
+        // Only the request that actually initiates the refresh observes it
+        // (checked against `promises` BEFORE resolve() registers the new
+        // in-flight promise): concurrent requests in the half-TTL window join
+        // the same deduped lookup and would otherwise emit one doc each, with
+        // attach-relative durations — the doc denotes the background lookup
+        // itself, not a per-request wait (nothing awaits a refresh).
+        const write = traceWrite(opts.trace)
+        const initiated = write !== null && !promises.has(hostname)
+        const promise = resolve(hostname, { ttl, negativeTTL, lookup })
+        if (initiated) {
+          // Side-observe a copy of the chain: resolve() never rejects (it
+          // settles with an [err, val] tuple) and .then returns a new promise,
+          // so the shared in-flight promise's other consumers are unaffected.
+          const started = performance.now()
+          promise.then(([err, val]) => {
+            traceSafe(
+              write,
+              {
+                id: opts.id ?? null,
+                url: traceUrl(opts),
+                source: 'refresh',
+                durationMs: Math.round(performance.now() - started),
+                records: err ? null : val.length,
+                err: err ? traceErr(err) : null,
+              },
+              'undici:dns',
+            )
+          })
+        }
       }
 
       url.hostname = net.isIPv6(record.address) ? `[${record.address}]` : record.address
@@ -265,6 +341,29 @@ export default () => (dispatch) => {
           if (err.code != null && CONNECTION_ERROR_CODES.has(err.code)) {
             // The IP is bad/unreachable — drop it from rotation immediately.
             record.expires = 0
+
+            // Cold path (connection error) — opts is the dispatch closure's;
+            // eviction stays allocation-free while tracing is off.
+            const write = traceWrite(opts.trace)
+            if (write !== null) {
+              const evictedAt = getFastNow()
+              let siblings = 0
+              for (const x of records) {
+                if (x.expires >= evictedAt) {
+                  siblings++
+                }
+              }
+              traceSafe(
+                write,
+                {
+                  hostname: hostname.slice(0, 256),
+                  address: String(record.address).slice(0, 256),
+                  err: traceErr(err),
+                  siblings,
+                },
+                'undici:dns-evict',
+              )
+            }
           } else {
             // Reachable IP, request failed for an unrelated reason (timeout
             // mid-stream, size mismatch, ...) — penalize softly, don't evict.

package/lib/interceptor/log.js

@@ -1,4 +1,5 @@
 import { DecoratorHandler, parseHeaders } from '../utils.js'
+import { traceWrite, traceSafe, traceErr, traceUrl } from '../trace.js'
 
 const kGlobalIndex = Symbol.for('@nxtedition/nxt-undici#globalIndex')
 const kGlobalArray = Symbol.for('@nxtedition/nxt-undici#globalArray')
@@ -141,6 +142,18 @@ class Handler extends DecoratorHandler {
   #ureq
   #logger
 
+  // Trace emission (op 'undici:request') lives in this handler alongside
+  // logging: both observe the same lifecycle (start, status, bytes, terminal
+  // event, sync-dispatch-throw finalization), so a second decorator layer
+  // would duplicate the bookkeeping. `#write` is the trace fn resolved once
+  // per request (capture-once: the same fn emits both the start and the end
+  // doc, so a writer flipping mid-request cannot break the pairing) and null
+  // when tracing is off. Logging and tracing are independently optional; the
+  // dispatch entry only constructs this handler when at least one is active.
+  #write
+  #traceUrl
+  #upgraded = false
+
   #abort
   #aborted = false
   #pos = 0
@@ -153,20 +166,39 @@ class Handler extends DecoratorHandler {
     end: -1,
   }
 
+  #opts
   #statusCode
   #headers
 
-  constructor(logOpts, opts, { handler }) {
+  constructor(write, logOpts, opts, { handler }) {
     super(handler)
 
-    this.#ureq = sanitizeRequest(opts)
-    this.#logger = opts.logger.child({ ureq: this.#ureq })
+    this.#opts = opts
+    this.#write = write
+
+    if (write !== null) {
+      this.#traceUrl = traceUrl(opts)
 
-    if (logOpts?.bindings) {
-      this.#logger = this.#logger.child(logOpts?.bindings)
+      traceSafe(
+        write,
+        { phase: 'start', id: opts.id ?? null, method: opts.method ?? null, url: this.#traceUrl },
+        'undici:request',
+      )
+    }
+
+    if (opts.logger) {
+      this.#ureq = sanitizeRequest(opts)
+      this.#logger = opts.logger.child({ ureq: this.#ureq })
+
+      if (logOpts?.bindings) {
+        this.#logger = this.#logger.child(logOpts?.bindings)
+      }
+
+      this.#logger.debug('upstream request started')
+    } else {
+      this.#logger = null
     }
 
-    this.#logger.debug('upstream request started')
     this.#timing.created = this.#created + performance.timeOrigin
 
     this[kGlobalArray] = globalThis[kGlobalArray] ??= []
@@ -190,8 +222,13 @@ class Handler extends DecoratorHandler {
 
   onUpgrade(statusCode, headers, socket) {
     this.#timing.headers = performance.now() - this.#created
+    this.#statusCode = statusCode
+    // After an upgrade the socket is handed over and no onComplete/onError
+    // will ever arrive — close of the upgraded socket is the end of the
+    // request. Bytes are not tracked on an upgraded socket.
+    this.#upgraded = true
 
-    this.#logger.debug(
+    this.#logger?.debug(
       {
         ures: { statusCode, headers: sanitizeHeaders(headers) },
         elapsedTime: this.#timing.headers,
@@ -200,8 +237,8 @@ class Handler extends DecoratorHandler {
     )
 
     socket.on('close', () => {
-      this.#logger.debug('upstream request socket closed')
-      this.onDone()
+      this.#logger?.debug('upstream request socket closed')
+      this.onDone(null)
     })
 
     super.onUpgrade(statusCode, headers, socket)
@@ -230,30 +267,32 @@ class Handler extends DecoratorHandler {
   onComplete(trailers) {
     this.#timing.end = performance.now() - this.#created
 
-    const data = {
-      ureq: this.#ureq,
-      ures: {
-        statusCode: this.#statusCode,
-        headers: this.#headers,
-        timing: this.#timing,
-        bytesRead: this.#pos,
-        bytesReadPerSecond:
-          this.#timing.data >= 0 && this.#timing.end > this.#timing.data
-            ? (this.#pos * 1e3) / (this.#timing.end - this.#timing.data)
-            : 0,
-      },
-      elapsedTime: this.#timing.end,
-    }
+    if (this.#logger) {
+      const data = {
+        ureq: this.#ureq,
+        ures: {
+          statusCode: this.#statusCode,
+          headers: this.#headers,
+          timing: this.#timing,
+          bytesRead: this.#pos,
+          bytesReadPerSecond:
+            this.#timing.data >= 0 && this.#timing.end > this.#timing.data
+              ? (this.#pos * 1e3) / (this.#timing.end - this.#timing.data)
+              : 0,
+        },
+        elapsedTime: this.#timing.end,
+      }
 
-    if (this.#statusCode >= 500) {
-      this.#logger.error(data, 'upstream request completed')
-    } else if (this.#statusCode >= 400) {
-      this.#logger.warn(data, 'upstream request completed')
-    } else {
-      this.#logger.debug(data, 'upstream request completed')
+      if (this.#statusCode >= 500) {
+        this.#logger.error(data, 'upstream request completed')
+      } else if (this.#statusCode >= 400) {
+        this.#logger.warn(data, 'upstream request completed')
+      } else {
+        this.#logger.debug(data, 'upstream request completed')
+      }
     }
 
-    this.onDone()
+    this.onDone(null)
 
     super.onComplete(trailers)
   }
@@ -261,33 +300,40 @@ class Handler extends DecoratorHandler {
   onError(err) {
     this.#timing.end = performance.now() - this.#created
 
-    const data = {
-      ures: {
-        statusCode: this.#statusCode || undefined,
-        headers: this.#headers,
-        timing: this.#timing,
-        bytesRead: this.#pos,
-        bytesReadPerSecond:
-          this.#timing.data >= 0 && this.#timing.end > this.#timing.data
-            ? (this.#pos * 1e3) / (this.#timing.end - this.#timing.data)
-            : 0,
-      },
-      elapsedTime: this.#timing.end,
-      err,
-    }
+    if (this.#logger) {
+      const data = {
+        ures: {
+          statusCode: this.#statusCode || undefined,
+          headers: this.#headers,
+          timing: this.#timing,
+          bytesRead: this.#pos,
+          bytesReadPerSecond:
+            this.#timing.data >= 0 && this.#timing.end > this.#timing.data
+              ? (this.#pos * 1e3) / (this.#timing.end - this.#timing.data)
+              : 0,
+        },
+        elapsedTime: this.#timing.end,
+        err,
+      }
 
-    if (this.#aborted) {
-      this.#logger.debug(data, 'upstream request aborted')
-    } else {
-      this.#logger.error(data, 'upstream request failed')
+      if (this.#aborted) {
+        this.#logger.debug(data, 'upstream request aborted')
+      } else {
+        this.#logger.error(data, 'upstream request failed')
+      }
     }
 
-    this.onDone()
+    this.onDone(err)
 
     super.onError(err)
   }
 
-  onDone() {
+  // Terminal finalization, reached exactly once per request from every end
+  // path (onComplete, onError, upgraded-socket close, onDispatchError): the
+  // in-flight registry entry is the once-guard. Deregistration happens BEFORE
+  // the trace end doc is emitted so a misbehaving writer can never observe —
+  // or re-enter — a handler that still looks in flight.
+  onDone(err) {
     if (this[kGlobalIndex] !== -1) {
       const tmp = this[kGlobalArray].pop()
       if (tmp !== this) {
@@ -295,16 +341,33 @@ class Handler extends DecoratorHandler {
         tmp[kGlobalIndex] = this[kGlobalIndex]
       }
       this[kGlobalIndex] = -1
+
+      if (this.#write !== null) {
+        traceSafe(
+          this.#write,
+          {
+            phase: 'end',
+            id: this.#opts.id ?? null,
+            method: this.#opts.method ?? null,
+            url: this.#traceUrl,
+            statusCode: this.#statusCode ?? null,
+            durationMs: Math.round(performance.now() - this.#created),
+            bytes: this.#upgraded ? null : this.#pos,
+            err: err != null ? traceErr(err) : null,
+          },
+          'undici:request',
+        )
+      }
     }
   }
 
   // Finalization for a request whose inner dispatch threw synchronously:
   // undici never took ownership of the handler, so no terminal callback
-  // (onError/onComplete) will ever arrive. Log the failure and deregister
-  // from the in-flight registry. Deliberately does NOT forward onError —
-  // the dispatch entry below rethrows and an outer interceptor (lookup)
-  // delivers the error to the original handler chain, so forwarding here
-  // would double-deliver it.
+  // (onError/onComplete) will ever arrive. Log the failure, emit the trace
+  // end doc and deregister from the in-flight registry. Deliberately does
+  // NOT forward onError — the dispatch entry below rethrows and an outer
+  // interceptor (lookup) delivers the error to the original handler chain,
+  // so forwarding here would double-deliver it.
   onDispatchError(err) {
     if (this[kGlobalIndex] === -1) {
       // A terminal callback already ran before the error escaped dispatch
@@ -315,18 +378,22 @@ class Handler extends DecoratorHandler {
 
     this.#timing.end = performance.now() - this.#created
 
-    this.#logger.error({ err, elapsedTime: this.#timing.end }, 'upstream request failed')
+    this.#logger?.error({ err, elapsedTime: this.#timing.end }, 'upstream request failed')
 
-    this.onDone()
+    this.onDone(err)
   }
 }
 
 export default (logOpts) => (dispatch) => (opts, handler) => {
-  if (!opts.logger) {
+  // Capture-once per request (see Handler#write). Resolution cost when both
+  // logging and tracing are off is one property read plus a typeof check.
+  const write = traceWrite(opts.trace)
+
+  if (!opts.logger && write === null) {
     return dispatch(opts, handler)
   }
 
-  const logHandler = new Handler(logOpts, opts, { handler })
+  const logHandler = new Handler(write, logOpts, opts, { handler })
 
   try {
     return dispatch(opts, logHandler)

package/lib/interceptor/lookup.js

@@ -1,4 +1,24 @@
 import { DecoratorHandler } from '../utils.js'
+import { traceWrite, traceSafe, traceErr, traceUrl } from '../trace.js'
+
+// Emit the single `undici:lookup` doc for an origin resolution: an async
+// success carries the resolved origin, a failure carries the error tag. `url`
+// is the requested origin+path; `resolved` is bounded like every other
+// caller-influenced string.
+function traceLookup(write, opts, start, resolved, err) {
+  traceSafe(
+    write,
+    {
+      id: opts.id ?? null,
+      method: opts.method ?? null,
+      url: traceUrl(opts),
+      resolved,
+      durationMs: Math.round(performance.now() - start),
+      err,
+    },
+    'undici:lookup',
+  )
+}
 
 export default () => (dispatch) => async (opts, handler) => {
   const lookup = opts.lookup
@@ -7,6 +27,16 @@ export default () => (dispatch) => async (opts, handler) => {
     return dispatch(opts, handler)
   }
 
+  // Per-request, resolved after the passthrough return; used at most once
+  // (one success OR failure doc per resolution).
+  const write = traceWrite(opts.trace)
+  const start = write !== null ? performance.now() : 0
+  // A success doc is only worth emitting when the callback fired
+  // asynchronously (service discovery): the default lookup calls back
+  // synchronously and would produce a ~0ms doc per request.
+  let resolvedAsync = false
+  let dispatched = false
+
   // Wrap so the catch below can't deliver a second onError: if a downstream
   // layer already reported a terminal callback and then let an error escape
   // dispatch synchronously, DecoratorHandler's #errored/#completed guards
@@ -15,16 +45,28 @@ export default () => (dispatch) => async (opts, handler) => {
 
   try {
     const origin = await new Promise((resolve, reject) => {
+      let sync = true
       const thenable = lookup(opts.origin, { signal: opts.signal ?? undefined }, (err, val) => {
+        if (!sync) {
+          resolvedAsync = true
+        }
         if (err) {
           reject(err)
         } else {
           resolve(val)
         }
       })
+      sync = false
 
       if (thenable != null) {
-        Promise.resolve(thenable).then(resolve, reject)
+        // A promise-returning lookup is always asynchronous (`.then` callbacks
+        // never run on the current stack), so its success doc must be emitted
+        // like the async-callback shape's — only the sync callback path is
+        // suppressed as noise.
+        Promise.resolve(thenable).then((val) => {
+          resolvedAsync = true
+          resolve(val)
+        }, reject)
       }
     })
 
@@ -32,8 +74,18 @@ export default () => (dispatch) => async (opts, handler) => {
       throw new Error('invalid origin: ' + origin)
     }
 
+    if (write !== null && resolvedAsync) {
+      traceLookup(write, opts, start, String(origin).slice(0, 256), null)
+    }
+
+    dispatched = true
     return dispatch({ ...opts, origin }, wrapped)
   } catch (err) {
+    // The try also covers the inner dispatch call — a sync throw escaping the
+    // inner chain is not a lookup failure and must not be attributed to one.
+    if (write !== null && !dispatched) {
+      traceLookup(write, opts, start, null, traceErr(err))
+    }
     wrapped.onError(err)
   }
 }

package/lib/interceptor/pressure.js

@@ -1,5 +1,6 @@
 import { parsePriority, Scheduler } from '@nxtedition/scheduler'
 import { DecoratorHandler } from '../utils.js'
+import { traceSafe, traceUrl, traceWrite, validateTrace } from '../trace.js'
 
 // Reconstruct a PSI-style pressure signal per origin from the request lifecycle
 // this interceptor observes, then expose latched flags so producers can back
@@ -67,6 +68,13 @@ class PressureMonitor {
   /** @type {ReturnType<typeof setInterval> | null} */
   #timer = null
 
+  // Optional trace writer for saturation-episode docs (op 'undici:pressure'):
+  // undefined defers to the per-thread global writer at each emission site,
+  // null disables. Sampling ticks in a timer with no request opts in scope, so
+  // the writer comes from the factory opts (like the scheduler limiter's
+  // #trace). All emission sites are cold — hysteresis latch transitions.
+  #trace
+
   #sampleInterval
   #tau
   #someHi
@@ -85,7 +93,9 @@ class PressureMonitor {
     fullLo = 0.1,
     errHi = 0.5,
     errLo = 0.2,
+    trace,
   } = {}) {
+    this.#trace = validateTrace(trace)
     this.#sampleInterval = sampleInterval
     this.#tau = tau
     this.#someHi = someHi
@@ -120,6 +130,7 @@ class PressureMonitor {
         shed: false, // latched: shed discretionary work
         paused: false, // latched: pause the producer
         degraded: false, // latched: error rate too high
+        episodes: null, // trace pairing: { some, full, error } of { write, start }, allocated on first engage
         lastSample: performance.now(),
       }
       this.#origins.set(key, rec)
@@ -132,7 +143,7 @@ class PressureMonitor {
   // loadavg-shaped EWMAs with a dt-aware gain (keeps the time-constant honest
   // under a jittery loop). Counters (completed) carry the `full` decision so a
   // burst that fills and drains between two samples can't alias it away.
-  #sample(rec, now) {
+  #sample(key, rec, now) {
     const dt = now - rec.lastSample
     if (dt <= 0) {
       return
@@ -155,21 +166,80 @@ class PressureMonitor {
     rec.full += a * ((fullNow ? 1 : 0) - rec.full)
     rec.errorRate += a * (errNow - rec.errorRate)
 
-    // Hysteresis: engage high, release low.
+    // Hysteresis: engage high, release low. Each latch brackets a saturation
+    // episode, traced as an 'undici:pressure' start/end pair.
     if (!rec.shed && rec.some > this.#someHi) {
       rec.shed = true
+      this.#traceEngage(key, rec, 'some', rec.some, now)
     } else if (rec.shed && rec.some < this.#someLo) {
       rec.shed = false
+      this.#traceRelease(key, rec, 'some', rec.some, now)
     }
     if (!rec.paused && rec.full > this.#fullHi) {
       rec.paused = true
+      this.#traceEngage(key, rec, 'full', rec.full, now)
     } else if (rec.paused && rec.full < this.#fullLo) {
       rec.paused = false
+      this.#traceRelease(key, rec, 'full', rec.full, now)
     }
     if (!rec.degraded && rec.errorRate > this.#errHi) {
       rec.degraded = true
+      this.#traceEngage(key, rec, 'error', rec.errorRate, now)
     } else if (rec.degraded && rec.errorRate < this.#errLo) {
       rec.degraded = false
+      this.#traceRelease(key, rec, 'error', rec.errorRate, now)
+    }
+  }
+
+  // Saturation-episode tracing (op 'undici:pressure'): one start/end doc pair
+  // per (origin, level) while a hysteresis latch is engaged — the scheduler
+  // limiter's limiter:backlog pattern, because an episode that can hang (an
+  // origin wedged under pressure) is exactly when in-progress visibility
+  // matters. `level` names the signal each latch trips on rather than the
+  // latch itself: shed -> 'some', paused -> 'full', degraded -> 'error' (the
+  // errorRate EWMA); `signal` is that EWMA at the transition. The write fn is
+  // captured once at engage and the SAME fn emits the release doc, so a writer
+  // toggling mid-episode can neither orphan nor split the pair — and a
+  // toggle-on mid-episode stays silent (nothing captured, no unpaired end).
+  #traceEngage(key, rec, level, signal, now) {
+    const write = traceWrite(this.#trace)
+    if (write !== null) {
+      rec.episodes ??= { some: null, full: null, error: null }
+      rec.episodes[level] = { write, start: now }
+      traceSafe(
+        write,
+        {
+          origin: traceUrl({ origin: key }),
+          level,
+          phase: 'start',
+          pending: rec.pending,
+          running: rec.running,
+          signal: Math.round(signal * 1000) / 1000,
+        },
+        'undici:pressure',
+      )
+    }
+  }
+
+  #traceRelease(key, rec, level, signal, now) {
+    const episode = rec.episodes?.[level]
+    if (episode != null) {
+      // Clear the pairing state BEFORE invoking the writer (traceSafe only
+      // contains throws) so a fresh episode's capture can't be clobbered.
+      rec.episodes[level] = null
+      traceSafe(
+        episode.write,
+        {
+          origin: traceUrl({ origin: key }),
+          level,
+          phase: 'end',
+          pending: rec.pending,
+          running: rec.running,
+          signal: Math.round(signal * 1000) / 1000,
+          durationMs: Math.round(now - episode.start),
+        },
+        'undici:pressure',
+      )
     }
   }
 
@@ -179,7 +249,7 @@ class PressureMonitor {
   #tick() {
     const now = performance.now()
     for (const [key, rec] of this.#origins) {
-      this.#sample(rec, now)
+      this.#sample(key, rec, now)
       if (
         rec.pending === 0 &&
         rec.running === 0 &&
@@ -280,6 +350,19 @@ class PressureMonitor {
       clearInterval(this.#timer)
       this.#timer = null
     }
+    // Close still-engaged episodes before dropping the records: a monitor
+    // teardown is not a hang, and a start doc with no end would read as one
+    // forever (the pairing is exactly what open-episode alerting keys on).
+    // Emitted through each episode's captured fn, like any release.
+    const now = performance.now()
+    for (const [key, rec] of this.#origins) {
+      if (rec.episodes != null) {
+        // #traceRelease no-ops per level unless an episode was captured.
+        this.#traceRelease(key, rec, 'some', rec.some, now)
+        this.#traceRelease(key, rec, 'full', rec.full, now)
+        this.#traceRelease(key, rec, 'error', rec.errorRate, now)
+      }
+    }
     this.#origins.clear()
   }