@quiesco/agent 0.0.0-stage → 0.1.1

package/src/singleton.ts

@@ -0,0 +1,18 @@
+/**
+ * One runtime per JS context, kept on globalThis so Fast Refresh re-evaluating modules reuses it
+ * (the DevTools hook and the patched globals must not be installed twice).
+ */
+import { AgentRuntime } from './runtime';
+
+const KEY = '__quiescoRuntime';
+
+export function getRuntime(): AgentRuntime {
+  const g = globalThis as unknown as Record<string, AgentRuntime | undefined>;
+  let rt = g[KEY];
+  if (rt === undefined) {
+    rt = new AgentRuntime();
+    rt.installEarly();
+    g[KEY] = rt;
+  }
+  return rt;
+}

package/src/stub.ts

@@ -0,0 +1,28 @@
+/**
+ * Production stub: withQuiesco() (metro.cjs) resolves `@quiesco/agent` to this file in non-e2e builds
+ * (docs/spikes/06-prod-strip.md). It must export the same API as index.ts and pull in nothing else.
+ */
+import type { ReactNode } from 'react';
+
+import type { QuiescoApi } from './api-types';
+
+export type { Backdoor, QuiescoApi, StorageAdapter } from './api-types';
+
+export interface QuiescoRootProps {
+  children?: ReactNode;
+}
+
+export function QuiescoRoot({ children }: QuiescoRootProps): ReactNode {
+  return children ?? null;
+}
+
+const noop = (): void => {};
+
+/** No-ops in production: registrations are accepted and ignored. */
+export const quiesco: QuiescoApi = {
+  backdoor: () => noop,
+  onReset: () => noop,
+  registerStorage: () => noop,
+  launchArgs: () => ({}),
+  workerIndex: () => null,
+};

package/src/sync/frame-stable.ts

@@ -0,0 +1,142 @@
+/**
+ * Frame-stable tracker (requirements.md §6.2-5): the element tree's structure snapshot (type, testID,
+ * text, rounded rect of every host node) is unchanged for N consecutive frames (default 2). Catches
+ * UI-thread animations (e.g. Reanimated) that are invisible to the JS-side trackers.
+ *
+ * Sampling runs only while a waitForIdle is in progress (beginWait / endWait), so idle apps do not
+ * pay for snapshotting the tree every frame. Outside a wait it reports idle.
+ *
+ * When the tree never settles, describeBusy() says how many frames were sampled in how long (very few
+ * frames means a starved UI thread, not an animation) and which node differed between the last two
+ * different frames, so a sync timeout names the element that keeps changing.
+ */
+import { SyncDefaults } from '@quiesco/protocol';
+
+import type { IdleTracker } from './tracker';
+
+export interface FrameStableTrackerOptions {
+  /** Structure snapshot of the current element tree, one line per host node. */
+  snapshot: () => readonly string[];
+  frames?: number;
+  /** Default: `globalThis.requestAnimationFrame`. */
+  requestFrame?: (cb: () => void) => unknown;
+  cancelFrame?: (id: unknown) => void;
+  /** Clock for the diagnostics. Default: `Date.now`. */
+  now?: () => number;
+}
+
+const MAX_LINE = 120;
+
+function sameLines(a: readonly string[], b: readonly string[]): boolean {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+  return true;
+}
+
+const clip = (line: string | undefined): string =>
+  line === undefined ? '(none)' : line.length > MAX_LINE ? `${line.slice(0, MAX_LINE - 1)}…` : line;
+
+/** Where two snapshots first differ, as a short human-readable line. */
+export function describeChange(before: readonly string[], after: readonly string[]): string {
+  let i = 0;
+  while (i < before.length && i < after.length && before[i] === after[i]) i++;
+  const count = before.length === after.length ? '' : `node count ${before.length} → ${after.length}; `;
+  return `${count}first difference at node ${i}: ${clip(before[i])} → ${clip(after[i])}`;
+}
+
+export class FrameStableTracker implements IdleTracker {
+  readonly name = 'frame-stable';
+  private frames: number;
+  private waiting = 0;
+  private frameId: unknown = null;
+  private last: readonly string[] | null = null;
+  /** The snapshot before the most recent change (for describeBusy). */
+  private beforeChange: readonly string[] | null = null;
+  /** Consecutive sampled frames with the same snapshot, including the first. */
+  private same = 0;
+  private sampled = 0;
+  private startedAt = 0;
+
+  constructor(private readonly options: FrameStableTrackerOptions) {
+    this.frames = Math.max(1, options.frames ?? SyncDefaults.stableFrames);
+  }
+
+  setFrames(frames: number): void {
+    this.frames = Math.max(1, frames);
+  }
+
+  isIdle(): boolean {
+    return this.waiting === 0 || this.same >= this.frames;
+  }
+
+  describeBusy(): string[] {
+    if (this.isIdle()) return [];
+    if (this.sampled === 0) return ['no frame rendered yet (is the app in the foreground?)'];
+    const elapsed = this.now() - this.startedAt;
+    const lines = [`element tree changing: stable for ${this.same}/${this.frames} frames (${this.sampled} frames sampled in ${elapsed}ms)`];
+    if (this.beforeChange !== null && this.last !== null) lines.push(`last change: ${describeChange(this.beforeChange, this.last)}`);
+    return lines;
+  }
+
+  install(): void {}
+
+  uninstall(): void {
+    this.waiting = 0;
+    this.stop();
+  }
+
+  beginWait(): void {
+    if (this.waiting++ > 0) return;
+    this.last = null;
+    this.beforeChange = null;
+    this.same = 0;
+    this.sampled = 0;
+    this.startedAt = this.now();
+    this.schedule();
+  }
+
+  endWait(): void {
+    if (this.waiting === 0 || --this.waiting > 0) return;
+    this.stop();
+  }
+
+  private now(): number {
+    return (this.options.now ?? Date.now)();
+  }
+
+  private schedule(): void {
+    const raf = this.options.requestFrame ?? (globalThis as { requestAnimationFrame?: (cb: () => void) => unknown }).requestAnimationFrame;
+    if (raf === undefined) return;
+    this.frameId = raf(() => {
+      this.frameId = null;
+      if (this.waiting === 0) return;
+      this.sample();
+      this.schedule();
+    });
+  }
+
+  private sample(): void {
+    let snap: readonly string[];
+    try {
+      snap = this.options.snapshot();
+    } catch (e) {
+      snap = [`error: ${String(e)}`];
+    }
+    this.sampled++;
+    if (this.last !== null && sameLines(snap, this.last)) {
+      this.same++;
+    } else {
+      if (this.last !== null) this.beforeChange = this.last;
+      this.same = 1;
+    }
+    this.last = snap;
+  }
+
+  private stop(): void {
+    if (this.frameId !== null) {
+      const cancel = this.options.cancelFrame ?? (globalThis as { cancelAnimationFrame?: (id: unknown) => void }).cancelAnimationFrame;
+      cancel?.(this.frameId);
+      this.frameId = null;
+    }
+  }
+}

package/src/sync/idle-callback.ts

@@ -0,0 +1,142 @@
+/**
+ * Pending idle-callback tracker (requirements.md §6.2-4, tracker name `idle-callback`):
+ * - `requestIdleCallback` callbacks not yet run (RN 0.88 removed InteractionManager and recommends it).
+ * - On older React Native versions that still have `InteractionManager`, its open interaction
+ *   handles and not-yet-run `runAfterInteractions` tasks.
+ */
+import type { IdleTracker } from './tracker';
+import { isFunction, patch } from './tracker';
+
+type RicFn = (this: unknown, cb: unknown, options?: unknown) => unknown;
+type CancelFn = (this: unknown, id: unknown) => void;
+
+export interface IdleCallbackGlobals {
+  requestIdleCallback?: RicFn;
+  cancelIdleCallback?: CancelFn;
+}
+
+/** The parts of the legacy `InteractionManager` API that are tracked. */
+export interface InteractionManagerLike {
+  createInteractionHandle: (this: unknown) => unknown;
+  clearInteractionHandle: (this: unknown, handle: unknown) => void;
+  runAfterInteractions: (this: unknown, task?: unknown) => { then?: unknown; cancel?: unknown } | undefined;
+}
+
+export interface IdleCallbackTrackerOptions {
+  target?: IdleCallbackGlobals;
+  /** Pass React Native's `InteractionManager` when it exists (RN < 0.88). */
+  interactionManager?: InteractionManagerLike | null;
+  now?: () => number;
+}
+
+export class IdleCallbackTracker implements IdleTracker {
+  readonly name = 'idle-callback';
+  private readonly callbacks = new Map<unknown, { since: number; name: string }>();
+  private readonly handles = new Set<unknown>();
+  private readonly tasks = new Map<number, number>();
+  private readonly restores: (() => void)[] = [];
+  private readonly target: IdleCallbackGlobals;
+  private readonly now: () => number;
+  private nextTask = 1;
+  private readonly attached = new Set<InteractionManagerLike>();
+
+  constructor(private readonly options: IdleCallbackTrackerOptions = {}) {
+    this.target = options.target ?? (globalThis as unknown as IdleCallbackGlobals);
+    this.now = options.now ?? Date.now;
+  }
+
+  isIdle(): boolean {
+    return this.callbacks.size === 0 && this.handles.size === 0 && this.tasks.size === 0;
+  }
+
+  describeBusy(): string[] {
+    const t = this.now();
+    const out = [...this.callbacks.values()].map((c) => `requestIdleCallback(${c.name}) ${t - c.since}ms`);
+    if (this.handles.size > 0) out.push(`InteractionManager: ${this.handles.size} open interaction handle(s)`);
+    for (const since of this.tasks.values()) out.push(`InteractionManager.runAfterInteractions task ${t - since}ms`);
+    return out;
+  }
+
+  install(): void {
+    if (this.restores.length > 0) return;
+    const self = this;
+    const g = this.target;
+    if (isFunction(g.requestIdleCallback) && isFunction(g.cancelIdleCallback)) {
+      const tg = g as Required<IdleCallbackGlobals>;
+      this.restores.push(
+        patch(tg, 'requestIdleCallback', (original) =>
+          function (this: unknown, cb: unknown, options?: unknown) {
+            if (!isFunction(cb)) return original.call(this, cb, options);
+              const wrapped = function (this: unknown, ...a: unknown[]) {
+              self.callbacks.delete(id);
+              return (cb as (...x: unknown[]) => unknown).apply(this, a);
+            };
+            const id: unknown = original.call(this, wrapped, options);
+            self.callbacks.set(id, { since: self.now(), name: cb.name || 'anonymous' });
+            return id;
+          },
+        ),
+        patch(tg, 'cancelIdleCallback', (original) =>
+          function (this: unknown, id: unknown) {
+            self.callbacks.delete(id);
+            return original.call(this, id);
+          },
+        ),
+      );
+    }
+    if (this.options.interactionManager != null) this.attachInteractionManager(this.options.interactionManager);
+  }
+
+  /**
+   * Track a legacy InteractionManager. Separate from install() so the runtime can look it up after the
+   * app has started (requiring react-native at agent import time would be too early).
+   */
+  attachInteractionManager(im: InteractionManagerLike): void {
+    if (this.attached.has(im)) return;
+    this.attached.add(im);
+    const self = this;
+    this.restores.push(
+      patch(im, 'createInteractionHandle', (original) =>
+        function (this: unknown) {
+          const h = original.call(this);
+          self.handles.add(h);
+          return h;
+        },
+      ),
+      patch(im, 'clearInteractionHandle', (original) =>
+        function (this: unknown, h: unknown) {
+          self.handles.delete(h);
+          return original.call(this, h);
+        },
+      ),
+      patch(im, 'runAfterInteractions', (original) =>
+        function (this: unknown, task?: unknown) {
+          const result = original.call(this, task);
+          const id = self.nextTask++;
+          self.tasks.set(id, self.now());
+          const done = (): void => {
+            self.tasks.delete(id);
+          };
+          if (result != null && isFunction(result.then)) (result.then as (a: () => void, b: () => void) => unknown).call(result, done, done);
+          else done();
+          if (result != null && isFunction(result.cancel)) {
+            const cancel = result.cancel;
+            result.cancel = function (this: unknown, ...a: never[]) {
+              done();
+              return cancel.apply(this, a);
+            };
+          }
+          return result;
+        },
+      ),
+    );
+  }
+
+  uninstall(): void {
+    while (this.restores.length > 0) this.restores.pop()?.();
+    this.attached.clear();
+    this.callbacks.clear();
+    this.handles.clear();
+    this.tasks.clear();
+  }
+}

package/src/sync/index.ts

@@ -0,0 +1,17 @@
+export type { Clock, IdleTracker } from './tracker';
+export { realClock } from './tracker';
+export { NetworkTracker } from './network';
+export type { FetchFn, NetworkTrackerOptions, UrlPattern } from './network';
+export { TimerTracker } from './timer';
+export type { TimerGlobals, TimerTrackerOptions } from './timer';
+export { ReactTracker } from './react';
+export type { ReactWorkSource } from './react';
+export { IdleCallbackTracker } from './idle-callback';
+export type { IdleCallbackTrackerOptions, InteractionManagerLike } from './idle-callback';
+export { FrameStableTracker } from './frame-stable';
+export type { FrameStableTrackerOptions } from './frame-stable';
+export { SyncEngine } from './wait-for-idle';
+export type { WaitForIdleOptions } from './wait-for-idle';
+export { NativeSettleTracker } from './native-settle';
+export type { NativeSettleSource } from './native-settle';
+export { OfflineGate, ownConnection } from './offline';

package/src/sync/native-settle.ts

@@ -0,0 +1,41 @@
+/**
+ * Native settle tracker (tracker name `native`): native UI that JS cannot see is still moving —
+ * a view controller transition (navigation push / pop, Modal presentation), the software keyboard
+ * moving or just used. Read synchronously from @quiesco/native (`idleState`, sampled every frame on
+ * the UI thread). Present only when the native module offers it (iOS); otherwise always idle.
+ *
+ * Why: UIKit drops a navigation update or a Modal presentation that arrives during a transition, and
+ * touches during keyboard activity; the JS-side trackers report idle meanwhile (Phase 4.5 findings).
+ */
+import type { IdleTracker } from './tracker';
+
+export interface NativeSettleSource {
+  idleState?(): { settling: boolean; reasons: string[] };
+}
+
+export class NativeSettleTracker implements IdleTracker {
+  readonly name = 'native';
+
+  /** `source` is resolved lazily: the native module may load after the trackers are created. */
+  constructor(private readonly source: () => NativeSettleSource | null) {}
+
+  private state(): { settling: boolean; reasons: string[] } | null {
+    const s = this.source();
+    if (s === null || typeof s.idleState !== 'function') return null;
+    return s.idleState();
+  }
+
+  isIdle(): boolean {
+    return this.state()?.settling !== true;
+  }
+
+  describeBusy(): string[] {
+    const s = this.state();
+    if (s === null || !s.settling) return [];
+    return s.reasons.length > 0 ? s.reasons : ['native UI settling'];
+  }
+
+  install(): void {}
+
+  uninstall(): void {}
+}

package/src/sync/network.ts

@@ -0,0 +1,299 @@
+/**
+ * In-flight network tracker (requirements.md §6.2-1; Phase 6.10 hardening, findings「6.10 网络同步 spike」).
+ *
+ * - `fetch` (the global one, and `expo/fetch` imported directly through `wrapFetch`, see
+ *   src/expo-fetch.js): busy until the response arrives, then — rule A (HU 2026-11-10) — until the body is
+ *   read: a body read (`json()` / `text()` / …) started before the next macrotask keeps the request busy
+ *   until it settles; a response nobody reads ends there. A body read started later counts again, as its
+ *   own entry. `expo/fetch` (the native global fetch since SDK 56) resolves on the headers and streams the
+ *   body, so without this the app looked idle while `await res.json()` was still waiting.
+ * - `XMLHttpRequest`: until `loadend`. On React Native's whatwg-fetch, XHRs sent synchronously from
+ *   inside a tracked `fetch()` call are not counted a second time.
+ * - `WebSocket` / `EventSource`: only while connecting (until open, error or close); an open connection is
+ *   long-lived and never counts.
+ *
+ * `ignoreUrls` and the exempt predicate (the agent's own connection) apply to all of them.
+ */
+import type { IdleTracker } from './tracker';
+import { isFunction, patch, realClock } from './tracker';
+
+export type UrlPattern = RegExp | string;
+
+interface XhrLike {
+  addEventListener(type: string, listener: () => void): void;
+}
+interface XhrCtor {
+  prototype: {
+    open: (this: XhrLike, method: string, url: string | URL, ...rest: unknown[]) => unknown;
+    send: (this: XhrLike, body?: unknown) => unknown;
+  };
+}
+export type FetchFn = (this: unknown, input: unknown, init?: unknown) => Promise<unknown>;
+type SocketCtor = new (url: string | URL, ...rest: unknown[]) => { addEventListener(type: string, l: () => void): void };
+
+export interface NetworkGlobals {
+  fetch?: FetchFn;
+  XMLHttpRequest?: XhrCtor;
+  WebSocket?: SocketCtor;
+  EventSource?: SocketCtor;
+}
+
+export interface NetworkTrackerOptions {
+  target?: NetworkGlobals;
+  /** Requests whose URL matches are ignored (long polling, SSE, analytics). Strings match as substrings. */
+  ignoreUrls?: readonly UrlPattern[];
+  now?: () => number;
+  /** Runs `cb` on the next macrotask with an untracked timer (rule A's window for starting a body read). */
+  defer?: (cb: () => void) => void;
+}
+
+interface Request {
+  method: string;
+  url: string;
+  since: number;
+}
+
+/** Response methods that read the body. */
+const BODY_READERS = ['json', 'text', 'arrayBuffer', 'blob', 'bytes', 'formData'] as const;
+const PATCHED = Symbol.for('quiesco.trackedResponse');
+
+function urlOf(input: unknown): string {
+  if (typeof input === 'string') return input;
+  if (typeof input === 'object' && input !== null) {
+    const u = (input as { url?: unknown; href?: unknown }).url ?? (input as { href?: unknown }).href;
+    if (typeof u === 'string') return u;
+  }
+  return String(input);
+}
+
+function methodOf(input: unknown, init: unknown): string {
+  const m = (init as { method?: unknown } | undefined)?.method ?? (input as { method?: unknown } | null)?.method;
+  return typeof m === 'string' ? m.toUpperCase() : 'GET';
+}
+
+export class NetworkTracker implements IdleTracker {
+  readonly name = 'network';
+  private readonly pending = new Map<number, Request>();
+  private readonly xhrInfo = new WeakMap<object, { method: string; url: string }>();
+  private readonly restores: (() => void)[] = [];
+  private nextId = 1;
+  private insideFetch = 0;
+  private readonly target: NetworkGlobals;
+  private readonly now: () => number;
+  private readonly defer: (cb: () => void) => void;
+  private ignoreUrls: readonly UrlPattern[];
+  private exempt: (url: string) => boolean = () => false;
+
+  constructor(options: NetworkTrackerOptions = {}) {
+    this.target = options.target ?? (globalThis as unknown as NetworkGlobals);
+    this.now = options.now ?? Date.now;
+    this.defer = options.defer ?? ((cb) => void realClock.setTimeout(cb, 0));
+    this.ignoreUrls = options.ignoreUrls ?? [];
+  }
+
+  /** Applies to requests started from now on. */
+  setIgnoreUrls(patterns: readonly UrlPattern[]): void {
+    this.ignoreUrls = patterns;
+  }
+
+  /** Connections never tracked (the agent's own WebSocket). */
+  setExempt(exempt: (url: string) => boolean): void {
+    this.exempt = exempt;
+  }
+
+  isIdle(): boolean {
+    return this.pending.size === 0;
+  }
+
+  describeBusy(): string[] {
+    const t = this.now();
+    return [...this.pending.values()].map((r) => `${r.method} ${r.url} (${t - r.since}ms)`);
+  }
+
+  /** A fetch function that is tracked like the global one (used for `expo/fetch` imported directly). */
+  wrapFetch(original: FetchFn): FetchFn {
+    const self = this;
+    return function (this: unknown, input: unknown, init?: unknown) {
+      const url = urlOf(input);
+      if (self.ignored(url)) return original.call(this, input, init);
+      const method = methodOf(input, init);
+      const id = self.begin(method, url);
+      let p: Promise<unknown>;
+      self.insideFetch++;
+      try {
+        p = original.call(this, input, init);
+      } catch (e) {
+        self.end(id);
+        throw e;
+      } finally {
+        self.insideFetch--;
+      }
+      // Registered before the caller's handlers, so the response is wrapped before the app sees it.
+      p.then(
+        (res) => self.awaitBody(id, method, url, res),
+        () => self.end(id),
+      );
+      return p;
+    } as FetchFn;
+  }
+
+  install(): void {
+    if (this.restores.length > 0) return;
+    const self = this;
+    if (isFunction(this.target.fetch)) {
+      this.restores.push(patch(this.target, 'fetch', (original) => this.wrapFetch(original as FetchFn)));
+    }
+    const proto = this.target.XMLHttpRequest?.prototype;
+    if (proto !== undefined) {
+      this.restores.push(
+        patch(proto, 'open', (original) =>
+          function (this: XhrLike, method: string, url: string | URL, ...rest: unknown[]) {
+            self.xhrInfo.set(this, { method: String(method).toUpperCase(), url: urlOf(url) });
+            return original.call(this, method, url, ...rest);
+          },
+        ),
+        patch(proto, 'send', (original) =>
+          function (this: XhrLike, body?: unknown) {
+            const info = self.xhrInfo.get(this);
+            if (info === undefined || self.insideFetch > 0 || self.ignored(info.url)) return original.call(this, body);
+            const id = self.begin(info.method, info.url);
+            this.addEventListener('loadend', () => self.end(id));
+            try {
+              return original.call(this, body);
+            } catch (e) {
+              self.end(id);
+              throw e;
+            }
+          },
+        ),
+      );
+    }
+    this.trackConnecting('WebSocket', 'WS');
+    this.trackConnecting('EventSource', 'SSE');
+  }
+
+  uninstall(): void {
+    while (this.restores.length > 0) this.restores.pop()?.();
+    this.pending.clear();
+  }
+
+  /**
+   * A subclass that counts the connection until it opens, fails or closes. Subclassing keeps
+   * `instanceof`, the static constants and the app's own handlers.
+   */
+  private trackConnecting(key: 'WebSocket' | 'EventSource', label: string): void {
+    const Base = this.target[key];
+    if (!isFunction(Base)) return;
+    const self = this;
+    const Tracked = class extends Base {
+      constructor(url: string | URL, ...rest: unknown[]) {
+        super(url, ...rest);
+        const u = urlOf(url);
+        if (self.ignored(u)) return;
+        const id = self.begin(label, u);
+        const done = (): void => self.end(id);
+        try {
+          for (const type of ['open', 'error', 'close']) this.addEventListener(type, done);
+        } catch {
+          done(); // no event API: never leave the app busy
+        }
+      }
+    };
+    Object.defineProperty(Tracked, 'name', { value: Base.name });
+    this.restores.push(patch(this.target, key, () => Tracked as SocketCtor));
+  }
+
+  /**
+   * Rule A: keep the request busy until the next macrotask; a body read started by then keeps it busy
+   * until the read settles. Reads started later are tracked on their own.
+   */
+  private awaitBody(id: number, method: string, url: string, res: unknown): void {
+    let reading = false;
+    const patched = this.wrapBody(res, method, url, () => {
+      if (reading || !this.pending.has(id)) return null;
+      reading = true;
+      return id;
+    });
+    if (!patched) {
+      this.end(id);
+      return;
+    }
+    this.defer(() => {
+      if (!reading) this.end(id);
+    });
+  }
+
+  /**
+   * Wraps the body readers of a response (and of its clones). `claim()` returns the pending request id
+   * the read continues, or null to track the read as a new entry. False when nothing could be wrapped.
+   */
+  private wrapBody(res: unknown, method: string, url: string, claim: () => number | null): boolean {
+    if (typeof res !== 'object' || res === null) return false;
+    const r = res as Record<string | symbol, unknown>;
+    if (r[PATCHED] === true) return true;
+    const self = this;
+    let wrapped = false;
+    // whatwg-fetch's json() calls this.text(): a read made from inside another one is the same read.
+    let inside = 0;
+    try {
+      for (const m of BODY_READERS) {
+        const read = r[m];
+        if (!isFunction(read)) continue;
+        r[m] = function (this: unknown, ...args: unknown[]) {
+          if (inside > 0) return (read as (...a: unknown[]) => unknown).apply(this, args);
+          const id = claim() ?? self.begin(method, `${url} (body)`);
+          let p: unknown;
+          inside++;
+          try {
+            p = (read as (...a: unknown[]) => unknown).apply(this, args);
+          } catch (e) {
+            self.end(id);
+            throw e;
+          } finally {
+            inside--;
+          }
+          if (p instanceof Promise || (typeof p === 'object' && p !== null && isFunction((p as { then?: unknown }).then))) {
+            (p as Promise<unknown>).then(
+              () => self.end(id),
+              () => self.end(id),
+            );
+          } else {
+            self.end(id);
+          }
+          return p;
+        };
+        wrapped = true;
+      }
+      const clone = r['clone'];
+      if (isFunction(clone)) {
+        r['clone'] = function (this: unknown, ...args: unknown[]) {
+          const c = (clone as (...a: unknown[]) => unknown).apply(this, args);
+          self.wrapBody(c, method, url, () => null);
+          return c;
+        };
+      }
+      Object.defineProperty(r, PATCHED, { value: true });
+    } catch {
+      // Frozen or exotic response: fall back to ending at the headers.
+    }
+    return wrapped;
+  }
+
+  private ignored(url: string): boolean {
+    if (this.exempt(url)) return true;
+    for (const p of this.ignoreUrls) {
+      if (typeof p === 'string' ? url.includes(p) : ((p.lastIndex = 0), p.test(url))) return true;
+    }
+    return false;
+  }
+
+  private begin(method: string, url: string): number {
+    const id = this.nextId++;
+    this.pending.set(id, { method, url, since: this.now() });
+    return id;
+  }
+
+  private end(id: number): void {
+    this.pending.delete(id);
+  }
+}