@fairfox/polly 0.52.0 → 0.54.0

package/dist/src/shared/lib/mesh-webrtc-adapter.d.ts

@@ -45,6 +45,7 @@
  *   signalling client.
  */
 import { type Message, NetworkAdapter, type PeerId, type PeerMetadata } from "@automerge/automerge-repo/slim";
+import type { MeshKeyring } from "./mesh-network-adapter";
 import type { MeshSignalingClient } from "./mesh-signaling-client";
 /** Standard STUN servers for NAT traversal. In production, callers who
  * need TURN fallback for peers behind symmetric NATs should replace this
@@ -64,8 +65,41 @@ export interface MeshWebRTCAdapterOptions {
      * one by sending an SDP offer through the signalling channel. Peers
      * not in this list can still connect by sending an offer *to* this
      * adapter. The natural source for this list is the keyring's
-     * knownPeers map keys. */
+     * knownPeers map keys.
+     *
+     * Used only when {@link keyringSource} is not supplied. With
+     * `keyringSource` set the adapter reads `knownPeers` live from the
+     * keyring on every initiation decision, which is the shape
+     * {@link createMeshClient} wires up so post-construction
+     * {@link applyPairingToken} calls take effect without the consumer
+     * having to call {@link MeshWebRTCAdapter.addKnownPeer} by hand. */
     knownPeerIds?: string[];
+    /** Live keyring source. When supplied, the adapter reads
+     * `knownPeers` from `keyringSource()` on every initiation decision
+     * instead of a Set captured at construction. Combined with the
+     * periodic re-sweep started in {@link MeshWebRTCAdapter.connect},
+     * this makes mutations to `keyring.knownPeers` — including the ones
+     * produced by {@link applyPairingToken} after the mesh client is up
+     * — visible to the dial path within at most one sweep interval. The
+     * crypto layer already re-reads the keyring on every send and
+     * receive; this option closes the same loop for the WebRTC adapter.
+     *
+     * Polly issue #103: without this, a long-lived daemon that pairs a
+     * new device after its mesh client is constructed never dials the
+     * new peer — the adapter's captured Set stays stale even though the
+     * keyring contains the new entry, and the lex-tie-break rule in
+     * {@link MeshWebRTCAdapter.shouldInitiateTo} can leave both peers
+     * waiting for the other to offer indefinitely. */
+    keyringSource?: () => MeshKeyring;
+    /** How often the adapter re-evaluates whether to dial peers in the
+     * signalling roster. The sweep is what catches peers that became
+     * authorised in the keyring after their `peer-joined` notification
+     * already fired — the adapter has no other event to hang the retry
+     * on, so it polls. Cheap: one Map lookup per present peer, fired at
+     * most once per interval. Defaults to 2000ms; tests override to
+     * shorten the failure budget. Set to 0 to disable the sweep
+     * (the captured-set behaviour, kept only for migration). */
+    knownPeersRefreshIntervalMs?: number;
     /** Optional ICE server list override. Defaults to {@link DEFAULT_ICE_SERVERS}. */
     iceServers?: RTCIceServer[];
     /** Optional data channel label. Defaults to "polly-mesh". Applications
@@ -77,6 +111,78 @@ export interface MeshWebRTCAdapterOptions {
      * (e.g. `werift` or `@roamhq/wrtc`) when running outside a browser, or
      * to use a custom subclass for tests or instrumentation. */
     RTCPeerConnection?: typeof RTCPeerConnection;
+    /** When `true` (the default), the adapter yields to the event loop
+     * between the points where a large initial sync would otherwise hold
+     * the main thread for tens of seconds: between each batch of
+     * fragmented `RTCDataChannel.send` calls on the sender side, and at
+     * the boundary between reassembling a sync message and dispatching
+     * it (deserialise → MeshNetworkAdapter unwrap → Automerge
+     * `applyChanges`) on the receiver side. Set to `false` to recover
+     * the pre-#104 tight-loop behaviour; this is the configuration the
+     * `POLLY_104_DISABLE_FIX=1` falsification path in
+     * `examples/mesh-large-initial-sync` uses to demonstrate the bug
+     * against post-fix polly. Production callers should leave this at
+     * the default. */
+    syncYieldEnabled?: boolean;
+    /** Override the sync fragment chunk size. Defaults to
+     * {@link SYNC_FRAGMENT_CHUNK_SIZE} (60 KiB), which leaves header
+     * overhead inside werift's hard 64 KiB max-message-size cap.
+     * Setting this to 64 KiB recreates the pre-#104 fragmentation bug,
+     * where peer A's outbound fragments overshoot the cap and werift
+     * rejects them silently — sync stalls forever. Used by the
+     * `POLLY_104_DISABLE_FIX=1` falsification path. Production callers
+     * should leave this at the default. */
+    syncFragmentChunkSizeOverride?: number;
+}
+/** Payload of the polly-specific `"sync-progress"` event emitted by
+ * {@link MeshWebRTCAdapter}. Consumers can subscribe via the adapter's
+ * standard `.on()` surface (the same one that carries `peer-candidate`
+ * and `peer-disconnected`) to observe fragment receive and dispatch
+ * activity in real time, without polling
+ * {@link MeshWebRTCAdapter.getPeerStateSnapshot}. Polly issue #104
+ * item 7. */
+export interface SyncProgressEvent {
+    /** Remote peer the fragment or dispatch is for. */
+    peerId: string;
+    /** Lifecycle stage. `fragment-received` fires for each chunk that
+     * arrives during reassembly; `dispatch-applied` fires once the
+     * reassembled message has been emitted upward to Automerge. */
+    kind: "fragment-received" | "dispatch-applied";
+    /** Bytes carried by the chunk that triggered the event. Zero for
+     * `dispatch-applied`. */
+    bytesDelta: number;
+    /** Running total of fragments received for the current reassembly. */
+    chunksReceived: number;
+    /** Running total of bytes received for the current reassembly. */
+    bytesReceived: number;
+    /** Number of reassembled messages whose dispatch has been scheduled
+     * but not yet emitted upward to Automerge. */
+    applyBacklog: number;
+    /** `performance.now()` at event emission. */
+    at: number;
+}
+/** Per-peer view of an in-flight initial sync. Populated by
+ * {@link MeshWebRTCAdapter.handleSyncFragment} as fragments of a
+ * single reassembly arrive, and reset to `undefined` once the
+ * reassembled message has been dispatched. Exposed verbatim through
+ * {@link MeshWebRTCAdapter.getPeerStateSnapshot} so a consumer
+ * harness can observe progress mid-stream. Polly issue #104 item 7. */
+export interface InFlightSyncSnapshot {
+    /** Fragments received for the current reassembly. Cleared once
+     * reassembly completes. */
+    chunksReceived: number;
+    /** Bytes received across the fragments of the current reassembly.
+     * The reassembled message will be slightly smaller than this sum
+     * because each fragment carries a small header. */
+    bytesReceived: number;
+    /** `performance.now()` value at the last fragment arrival. */
+    lastChunkAt: number;
+    /** Count of reassembled messages whose dispatch has been
+     * scheduled but not yet run. With the receiver-side `setTimeout(0)`
+     * yield enabled, this is normally 0 or 1; with the yield
+     * disabled (the falsification path) dispatch runs synchronously
+     * and this stays 0. */
+    applyBacklog: number;
 }
 /**
  * Automerge-Repo NetworkAdapter backed by real WebRTC data channels.
@@ -90,8 +196,35 @@ export declare class MeshWebRTCAdapter extends NetworkAdapter {
     /** Peers this adapter is willing to dial. Mutable so callers that pair
      * a new device after construction (e.g. a CLI `add-device` process whose
      * mesh client is long-lived across the pair ceremony) can register the
-     * new peer with {@link addKnownPeer} without restarting the client. */
+     * new peer with {@link addKnownPeer} without restarting the client.
+     *
+     * Used only in the captured-set fallback path — when no
+     * {@link keyringSource} is supplied. With `keyringSource` set, the
+     * authoritative source is the live keyring and this Set is unused. */
     private readonly knownPeers;
+    /** Live keyring source, or undefined when the adapter is operating in
+     * the captured-set fallback shape. See the JSDoc on
+     * {@link MeshWebRTCAdapterOptions.keyringSource}. */
+    private readonly keyringSource;
+    /** Interval handle for the periodic re-sweep that catches peers
+     * already in the signalling roster when the keyring grew. Cleared in
+     * {@link MeshWebRTCAdapter.disconnect}. */
+    private knownPeersRefreshTimer;
+    /** Sweep interval. Resolved from
+     * {@link MeshWebRTCAdapterOptions.knownPeersRefreshIntervalMs} at
+     * construction. Defaults to 2000ms; tests override to 100–250ms. */
+    private readonly knownPeersRefreshIntervalMs;
+    /** When `true`, the sender side awaits between batches of fragment
+     * sends and the receiver side schedules dispatch via `setTimeout(0)`
+     * so the JS event loop can drain timers (including the consumer's
+     * own setInterval-based liveness probes) between large-message
+     * apply calls. Defaults to `true`; set to `false` only by the
+     * `POLLY_104_DISABLE_FIX` falsification path. */
+    private readonly syncYieldEnabled;
+    /** Resolved chunk size for fragmenting oversized messages.
+     * Defaults to {@link SYNC_FRAGMENT_CHUNK_SIZE}; can be overridden
+     * via {@link MeshWebRTCAdapterOptions.syncFragmentChunkSizeOverride}. */
+    private readonly syncFragmentChunkSize;
     /** Peers currently visible in the signalling roster — populated by
      * {@link handlePeersPresent} / {@link handlePeerJoined} and pruned by
      * {@link handlePeerLeft}. Read by {@link addKnownPeer} to decide
@@ -109,10 +242,18 @@ export declare class MeshWebRTCAdapter extends NetworkAdapter {
     private ready;
     private readyResolver;
     /** The peers this adapter will dial. Backward-compatible read accessor
-     * for callers that previously iterated the `knownPeerIds` array; the
-     * underlying storage is now a Set so mutations through
-     * {@link addKnownPeer} are O(1) and survive without re-allocation. */
+     * for callers that previously iterated the `knownPeerIds` array. With
+     * a {@link MeshWebRTCAdapterOptions.keyringSource} configured, the
+     * value is read live from the keyring; otherwise it falls back to the
+     * captured Set populated through the constructor and
+     * {@link addKnownPeer}. */
     get knownPeerIds(): string[];
+    /** True iff `remotePeerId` is currently in the authoritative
+     * knownPeers source — the live keyring when one was supplied, or
+     * the captured Set otherwise. Centralises the membership check so
+     * {@link shouldInitiateTo} and the JSDoc on
+     * {@link MeshWebRTCAdapterOptions.keyringSource} agree on the rule. */
+    private hasKnownPeer;
     /** Callback for incoming blob messages. Set by the blob store.
      *  Called with the sender's peer ID, the raw header object, and the
      *  binary payload (chunk data). */
@@ -124,6 +265,44 @@ export declare class MeshWebRTCAdapter extends NetworkAdapter {
      * RTCPeerConnection and data channel. Exposed for tests that assert
      * "exactly one channel per pair" after discovery settles. */
     peerSlotCount(): number;
+    /** Snapshot of the adapter's per-peer state at the moment of the
+     * call. Returned values are plain data — strings and booleans only —
+     * so consumers can log, assert on, or render them without retaining
+     * references into the adapter's internals.
+     *
+     * Polly issue #103 asked for an inspection surface so a consumer
+     * harness can answer "is the mesh layer in a known good state" from
+     * outside polly. This method is that surface. The fields mirror the
+     * three layers of the WebRTC connection lifecycle so a "stuck"
+     * connection can be diagnosed without reaching for the browser
+     * devtools: the SDP signalling state, the ICE checking state, and
+     * the unified RTCPeerConnection connection state. A `dataChannel`
+     * field reports whether the data channel — the thing the mesh
+     * actually carries bytes over — is open.
+     *
+     * Peers visible in the signalling roster but not yet dialled appear
+     * with `slot: undefined`, so a consumer can tell "we know about this
+     * peer in signalling but the WebRTC adapter has not started an
+     * offer yet" from "we have a slot in some negotiation state". */
+    getPeerStateSnapshot(): {
+        localPeerId: string;
+        knownPeerIds: string[];
+        presentPeerIds: string[];
+        peers: Array<{
+            peerId: string;
+            knownInKeyring: boolean;
+            presentInSignalling: boolean;
+            slot: undefined | {
+                signalingState: string;
+                iceConnectionState: string;
+                connectionState: string;
+                dataChannelState: string;
+                pendingSendCount: number;
+                pendingRemoteIceCount: number;
+                inFlightSync: InFlightSyncSnapshot | undefined;
+            };
+        }>;
+    };
     /** Handle the signalling server's `peer-joined` notification: a new
      * peer has appeared on the relay. If the peer is in `knownPeerIds`
      * and we do not already have a slot for it, and the tie-break rule
@@ -152,8 +331,22 @@ export declare class MeshWebRTCAdapter extends NetworkAdapter {
      * new entry. Calling this method propagates that into the adapter's
      * own allowlist; if the peer is already in the signalling roster and
      * the tie-break rule names us as the initiator, an SDP offer fires
-     * immediately. No-op if the peer is already known. */
+     * immediately. No-op if the peer is already known.
+     *
+     * When a {@link MeshWebRTCAdapterOptions.keyringSource} is configured
+     * the adapter already reads `knownPeers` live and the periodic sweep
+     * picks up the new entry within
+     * {@link MeshWebRTCAdapterOptions.knownPeersRefreshIntervalMs} on its
+     * own, so explicit calls to this method are not required for
+     * correctness — but remain supported for callers that want the
+     * "dial now if present" prompt without waiting for the next sweep. */
     addKnownPeer(remotePeerId: string): void;
+    /** Re-evaluate every peer currently in the signalling roster and
+     * dial the ones the keyring authorises that we do not already have
+     * a slot for. The periodic sweep started in {@link connect} calls
+     * this; consumers can call it manually to skip the wait after they
+     * apply a fresh pairing token. Idempotent. */
+    refreshKnownPeers(): void;
     private shouldInitiateTo;
     whenReady(): Promise<void>;
     /**
@@ -170,6 +363,13 @@ export declare class MeshWebRTCAdapter extends NetworkAdapter {
      */
     connect(peerId: PeerId, peerMetadata?: PeerMetadata): void;
     disconnect(): void;
+    /** Start the periodic re-sweep that catches peers added to the
+     * keyring after their `peer-joined` notification has already fired.
+     * No-op when no keyringSource was supplied — the captured-set
+     * fallback has no live source to re-read, so the sweep would be
+     * useless. No-op when the interval is configured to 0. */
+    private startKnownPeersSweep;
+    private stopKnownPeersSweep;
     /**
      * Send a sync message to a specific remote peer. If no RTCPeerConnection
      * exists yet, the adapter initiates one by producing an SDP offer and
@@ -177,13 +377,30 @@ export declare class MeshWebRTCAdapter extends NetworkAdapter {
      * queued until the data channel is open.
      */
     send(message: Message): void;
+    /** Number of consecutive fragment sends after which the sender
+     * yields to the macrotask queue when {@link syncYieldEnabled} is on.
+     * 8 × 64 KiB = 512 KiB of bytes between yields — small enough that
+     * a 5 MB sync produces many yield points (and the JS event loop
+     * drains the consumer's `setInterval` liveness probes between
+     * them), large enough that the per-yield overhead does not dominate
+     * the wire cost. */
+    private static readonly SEND_YIELD_EVERY_N_FRAGMENTS;
     /** Send raw wire bytes, fragmenting if they exceed the SCTP maxMessageSize
      *  cap. The default RTCDataChannel limit is 256 KiB in current Chrome and
      *  werift; oversized sends either throw, drop silently, or stall the
      *  channel, none of which surface as an error to the caller. Fragments
      *  use the same length-prefixed JSON header wire format as ordinary
      *  messages but carry a `sync-fragment` type that the receive path
-     *  detects and reassembles before deserialising. */
+     *  detects and reassembles before deserialising.
+     *
+     *  When {@link MeshWebRTCAdapterOptions.syncYieldEnabled} is true (the
+     *  default), the loop awaits the macrotask queue every
+     *  {@link SEND_YIELD_EVERY_N_FRAGMENTS} fragments so the JS event
+     *  loop drains between batches — without this, a 5–8 MB initial
+     *  sync produces 78–125 back-to-back `RTCDataChannel.send` calls in
+     *  a tight loop, starving anything else on the main thread (polly
+     *  issue #104, sender side). When the option is false the legacy
+     *  tight-loop shape is preserved for the falsification path. */
     private sendBytesMaybeFragmented;
     /**
      * Entry point the signalling client calls when it receives a signal
@@ -207,7 +424,31 @@ export declare class MeshWebRTCAdapter extends NetworkAdapter {
     private wireConnection;
     private wireDataChannel;
     private dispatchMessage;
+    /** Hand a deserialised Automerge message off to whoever is listening
+     * on this adapter's `"message"` event. When
+     * {@link MeshWebRTCAdapterOptions.syncYieldEnabled} is true (the
+     * default), the emit runs on a fresh macrotask so the crypto-unwrap
+     * and Automerge `applyChanges` chain downstream of this method does
+     * not sit on the same JS stack frame as the wire `onmessage` callback
+     * — that's the receiver-side starvation site polly issue #104
+     * documents. When the option is false the emit is synchronous,
+     * recovering the pre-fix shape used by the falsification path.
+     *
+     * The `viaFragmentPath` argument tags whether this dispatch came out
+     * of a reassembled fragment chain; only those carry an
+     * `inFlightSync` reassembly state worth bookkeeping. Small
+     * single-message dispatches yield but don't touch inFlightSync. */
+    private scheduleEmitMessage;
+    private finishInFlightSyncApply;
+    private emitSyncProgress;
     private handleSyncFragment;
+    /** Dispatch a reassembled fragment payload back through
+     * {@link dispatchMessage}, but tagged so the
+     * {@link scheduleEmitMessage} path knows it owes a
+     * `finishInFlightSyncApply` afterwards. Synchronous re-entry into
+     * `dispatchMessage` would lose that signal, so the post-fragment
+     * deserialise+emit is inlined here. */
+    private dispatchReassembled;
     /** Peer IDs with an open data channel, suitable for blob requests. */
     get connectedPeerIds(): string[];
     /** Send a pre-serialised blob message to a specific peer. Returns false

package/dist/src/shared/lib/sync-fragment.d.ts

@@ -17,12 +17,23 @@
  * does not mistake a sync fragment for a blob chunk.
  */
 /** Maximum bytes a single channel.send may carry without fragmentation.
- *  Chosen well below the 256 KiB SCTP cap so the framing header for a
- *  single chunk cannot push the wire frame over the limit. Matches the
- *  blob-transfer chunk size so the two transports have a consistent
- *  per-message footprint on the data channel. */
+ *  Werift (the node-side WebRTC implementation polly recommends for
+ *  CLI/daemon use) enforces a hard 64 KiB (65536 bytes) maxMessageSize
+ *  on its RTCDataChannel — anything larger is rejected with a
+ *  `max-message-size exceeded` error and silently drops the channel
+ *  for that send. Chrome's SCTP cap is 256 KiB and would tolerate
+ *  larger frames, but the threshold is chosen to fit inside werift's
+ *  cap WITH per-fragment header overhead included so a single mesh
+ *  deployment works on both transports. Matches the blob-transfer
+ *  chunk size so the two transports have a consistent per-message
+ *  footprint on the data channel. */
 export declare const SYNC_FRAGMENT_THRESHOLD: number;
-/** Chunk size used when a message exceeds the threshold. */
+/** Chunk size used when a message exceeds the threshold. Left at the
+ *  same value as {@link SYNC_FRAGMENT_THRESHOLD} so the framing
+ *  header (a JSON-encoded `SyncFragmentHeader` of ~90 bytes plus a
+ *  4-byte length prefix) does not push any fragment over werift's
+ *  64 KiB wire limit — see polly issue #104 for the failure mode
+ *  this guards against. */
 export declare const SYNC_FRAGMENT_CHUNK_SIZE: number;
 export interface SyncFragmentHeader {
     type: "sync-fragment";

package/dist/tools/test/src/visual/index.js

@@ -6135,12 +6135,23 @@ __export(exports_assert, {
   CallTracker: () => CallTracker,
   AssertionError: () => AssertionError
 });
-var __create2, __getProtoOf2, __defProp2, __getOwnPropNames2, __hasOwnProp2, __toESM2 = (mod, isNodeMode, target) => {
+function __accessProp2(key) {
+  return this[key];
+}
+var __create2, __getProtoOf2, __defProp2, __getOwnPropNames2, __hasOwnProp2, __toESMCache_node2, __toESMCache_esm2, __toESM2 = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node2 ??= new WeakMap : __toESMCache_esm2 ??= new WeakMap, cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
   target = mod != null ? __create2(__getProtoOf2(mod)) : {};
   let to = isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames2(mod))
     if (!__hasOwnProp2.call(to, key))
-      __defProp2(to, key, { get: () => mod[key], enumerable: true });
+      __defProp2(to, key, { get: __accessProp2.bind(mod, key), enumerable: true });
+  if (canCache)
+    cache.set(mod, to);
   return to;
 }, __commonJS2 = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports), require_shams, require_shams2, require_es_object_atoms, require_es_errors, require_eval, require_range, require_ref, require_syntax, require_type, require_uri, require_abs, require_floor, require_max, require_min, require_pow, require_round, require_isNaN, require_sign, require_gOPD, require_gopd, require_es_define_property, require_has_symbols, require_Reflect_getPrototypeOf, require_Object_getPrototypeOf, require_implementation, require_function_bind, require_functionCall, require_functionApply, require_reflectApply, require_actualApply, require_call_bind_apply_helpers, require_get, require_get_proto, require_hasown, require_get_intrinsic, require_call_bound, require_is_arguments, require_is_regex, require_safe_regex_test, require_generator_function, require_is_generator_function, require_is_callable, require_for_each, require_possible_typed_array_names, require_available_typed_arrays, require_define_data_property, require_has_property_descriptors, require_set_function_length, require_applyBind, require_call_bind, require_which_typed_array, require_is_typed_array, require_types, require_isBuffer, require_inherits_browser, require_inherits, require_util, require_errors, require_assertion_error, require_isArguments, require_implementation2, require_object_keys, require_implementation3, require_polyfill, require_implementation4, require_polyfill2, require_callBound, require_define_properties, require_shim, require_object_is, require_implementation5, require_polyfill3, require_shim2, require_is_nan, require_comparisons, require_assert, assert, AssertionError, CallTracker, deepEqual, deepStrictEqual, doesNotMatch, doesNotReject, doesNotThrow, equal, fail, ifError, match, notDeepEqual, notDeepStrictEqual, notEqual, notStrictEqual, ok, rejects, strict, strictEqual, throws, assert_default;
 var init_assert = __esm(() => {
@@ -9108,26 +9119,41 @@ var exports_zlib = {};
 __export(exports_zlib, {
   default: () => export_default
 });
+function __accessProp3(key) {
+  return this[key];
+}
+function __exportSetter2(name, newValue) {
+  this[name] = __returnValue2.bind(null, newValue);
+}
 var __create3, __getProtoOf3, __defProp3, __getOwnPropNames3, __hasOwnProp3, __reExport = (target, mod, secondTarget) => {
-  for (let key of __getOwnPropNames3(mod))
+  var keys = __getOwnPropNames3(mod);
+  for (let key of keys)
     if (!__hasOwnProp3.call(target, key) && key !== "default")
-      __defProp3(target, key, { get: () => mod[key], enumerable: true });
+      __defProp3(target, key, { get: __accessProp3.bind(mod, key), enumerable: true });
   if (secondTarget) {
-    for (let key of __getOwnPropNames3(mod))
+    for (let key of keys)
       if (!__hasOwnProp3.call(secondTarget, key) && key !== "default")
-        __defProp3(secondTarget, key, { get: () => mod[key], enumerable: true });
+        __defProp3(secondTarget, key, { get: __accessProp3.bind(mod, key), enumerable: true });
     return secondTarget;
   }
-}, __toESM3 = (mod, isNodeMode, target) => {
+}, __toESMCache_node3, __toESMCache_esm3, __toESM3 = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node3 ??= new WeakMap : __toESMCache_esm3 ??= new WeakMap, cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
   target = mod != null ? __create3(__getProtoOf3(mod)) : {};
   let to = isNodeMode || !mod || !mod.__esModule ? __defProp3(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames3(mod))
     if (!__hasOwnProp3.call(to, key))
-      __defProp3(to, key, { get: () => mod[key], enumerable: true });
+      __defProp3(to, key, { get: __accessProp3.bind(mod, key), enumerable: true });
+  if (canCache)
+    cache.set(mod, to);
   return to;
-}, __commonJS3 = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports), __export2 = (target, all) => {
+}, __commonJS3 = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports), __returnValue2 = (v) => v, __export2 = (target, all) => {
   for (var name in all)
-    __defProp3(target, name, { get: all[name], enumerable: true, configurable: true, set: (newValue) => all[name] = () => newValue });
+    __defProp3(target, name, { get: all[name], enumerable: true, configurable: true, set: __exportSetter2.bind(all, name) });
 }, require_zstream, require_common, require_trees, require_adler32, require_crc32, require_messages, require_deflate, require_inffast, require_inftrees, require_inflate, require_constants, require_binding, require_lib, exports_zlib2, import_browserify_zlib, export_default;
 var init_zlib = __esm(() => {
   __create3 = Object.create;
@@ -13991,4 +14017,4 @@ export {
   assertSafeUpdateMode
 };
 
-//# debugId=A8F0CA1BEDC12C8F64756E2164756E21
+//# debugId=51DC7226BD2C4BE464756E2164756E21