ember-source 6.12.0 → 7.0.0-beta.1

package/dist/{packages → dev/packages}/@glimmer/validator/index.js

@@ -1,12 +1,11 @@
-import '../../shared-chunks/debug-to-string-BsFOvUtQ.js';
+import '../../shared-chunks/debug-to-string-CFb7h0lY.js';
 import { g as getLast, b as asPresentArray } from '../../shared-chunks/present-B1rrjAVM.js';
-import { isDevelopingApp } from '@embroider/macros';
 import { assert, scheduleRevalidate } from '../global-context/index.js';
 
 /* eslint-disable @typescript-eslint/no-non-null-assertion -- @fixme */
 
 const debug = {};
-if (isDevelopingApp()) {
+{
   let CONSUMED_TAGS = null;
   const TRANSACTION_STACK = [];
 
@@ -164,6 +163,8 @@ function unwrap(val) {
   return val;
 }
 
+//////////
+
 const CONSTANT = 0;
 const INITIAL = 1;
 const VOLATILE = NaN;
@@ -218,7 +219,7 @@ const TYPE = Symbol('TAG_TYPE');
 
 // this is basically a const
 let ALLOW_CYCLES;
-if (isDevelopingApp()) {
+{
   ALLOW_CYCLES = new WeakMap();
 }
 function allowsCycles(tag) {
@@ -257,7 +258,7 @@ class MonomorphicTagImpl {
       lastChecked
     } = this;
     if (this.isUpdating) {
-      if (isDevelopingApp() && !allowsCycles(this)) {
+      if (!allowsCycles(this)) {
         throw new Error('Cycles in tags are not allowed');
       }
       this.lastChecked = ++$REVISION;
@@ -296,7 +297,7 @@ class MonomorphicTagImpl {
   static updateTag(_tag, _subtag) {
     // catch bug by non-TS users
 
-    if (isDevelopingApp() && _tag[TYPE] !== UPDATABLE_TAG_ID) {
+    if (_tag[TYPE] !== UPDATABLE_TAG_ID) {
       throw new Error('Attempted to update a tag that was not updatable');
     }
 
@@ -329,13 +330,12 @@ class MonomorphicTagImpl {
     }
   }
   static dirtyTag(tag, disableConsumptionAssertion) {
-    if (isDevelopingApp() &&
-    // catch bug by non-TS users
+    if (// catch bug by non-TS users
 
     !(tag[TYPE] === UPDATABLE_TAG_ID || tag[TYPE] === DIRYTABLE_TAG_ID)) {
       throw new Error('Attempted to dirty a tag that was not dirtyable');
     }
-    if (isDevelopingApp() && disableConsumptionAssertion !== true) {
+    if (disableConsumptionAssertion !== true) {
       // Usually by this point, we've already asserted with better error information,
       // but this is our last line of defense.
       unwrap(debug.assertTagNotConsumed)(tag);
@@ -408,13 +408,16 @@ valueForTag(tag1);
 DIRTY_TAG(tag3);
 valueForTag(tag1);
 
+/**
+ * An object that that tracks @tracked properties that were consumed.
+ */
 class Tracker {
   tags = new Set();
   last = null;
   add(tag) {
     if (tag === CONSTANT_TAG) return;
     this.tags.add(tag);
-    if (isDevelopingApp()) {
+    {
       unwrap(debug.markTagAsConsumed)(tag);
     }
     this.last = tag;
@@ -451,13 +454,13 @@ const OPEN_TRACK_FRAMES = [];
 function beginTrackFrame(debuggingContext) {
   OPEN_TRACK_FRAMES.push(CURRENT_TRACKER);
   CURRENT_TRACKER = new Tracker();
-  if (isDevelopingApp()) {
+  {
     unwrap(debug.beginTrackingTransaction)(debuggingContext);
   }
 }
 function endTrackFrame() {
   let current = CURRENT_TRACKER;
-  if (isDevelopingApp()) {
+  {
     if (OPEN_TRACK_FRAMES.length === 0) {
       throw new Error('attempted to close a tracking frame, but one was not open');
     }
@@ -471,7 +474,7 @@ function beginUntrackFrame() {
   CURRENT_TRACKER = null;
 }
 function endUntrackFrame() {
-  if (isDevelopingApp() && OPEN_TRACK_FRAMES.length === 0) {
+  if (OPEN_TRACK_FRAMES.length === 0) {
     throw new Error('attempted to close a tracking frame, but one was not open');
   }
   CURRENT_TRACKER = OPEN_TRACK_FRAMES.pop() || null;
@@ -483,7 +486,7 @@ function resetTracking() {
     OPEN_TRACK_FRAMES.pop();
   }
   CURRENT_TRACKER = null;
-  if (isDevelopingApp()) {
+  {
     return unwrap(debug.resetTrackingTransaction)();
   }
 }
@@ -504,7 +507,7 @@ const TAG = Symbol('TAG');
 const SNAPSHOT = Symbol('SNAPSHOT');
 const DEBUG_LABEL = Symbol('DEBUG_LABEL');
 function createCache(fn, debuggingLabel) {
-  if (isDevelopingApp() && !(typeof fn === 'function')) {
+  if (!(typeof fn === 'function')) {
     throw new Error(`createCache() must be passed a function as its first parameter. Called with: ${String(fn)}`);
   }
   let cache = {
@@ -513,7 +516,7 @@ function createCache(fn, debuggingLabel) {
     [TAG]: undefined,
     [SNAPSHOT]: -1
   };
-  if (isDevelopingApp()) {
+  {
     cache[DEBUG_LABEL] = debuggingLabel;
   }
   return cache;
@@ -545,7 +548,7 @@ function isConst(cache) {
   return isConstTag(tag);
 }
 function assertCache(value, fnName) {
-  if (isDevelopingApp() && !(typeof value === 'object' && FN in value)) {
+  if (!(typeof value === 'object' && FN in value)) {
     throw new Error(`${fnName}() can only be used on an instance of a cache created with createCache(). Called with: ${String(
     // eslint-disable-next-line @typescript-eslint/no-base-to-string -- @fixme
     value)}`);
@@ -554,7 +557,7 @@ function assertCache(value, fnName) {
 
 // replace this with `expect` when we can
 function assertTag(tag, cache) {
-  if (isDevelopingApp() && tag === undefined) {
+  if (tag === undefined) {
     throw new Error(`isConst() can only be used on a cache once getValue() has been called at least once. Called with cache function:\n\n${String(cache[FN])}`);
   }
 }
@@ -738,13 +741,19 @@ function trackedArray(data, options) {
   });
 }
 
-class TrackedMap {
-  #options;
-  #collection = createUpdatableTag();
-  #storages = new Map();
-  #vals;
-  #storageFor(key) {
-    const storages = this.#storages;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// Using a Proxy-based approach so that any new methods added to the Map
+// interface (like getOrInsert, getOrInsertComputed, etc.) are automatically
+// supported without needing to manually re-implement each one.
+
+function trackedMap(data, options) {
+  const equals = options?.equals ?? Object.is;
+  // TypeScript doesn't correctly resolve the overloads for calling the `Map`
+  // constructor for the no-value constructor. This resolves that.
+  const target = data instanceof Map ? new Map(data.entries()) : new Map(data ?? []);
+  const collection = createUpdatableTag();
+  const storages = new Map();
+  function storageFor(key) {
     let storage = storages.get(key);
     if (storage === undefined) {
       storage = createUpdatableTag();
@@ -752,134 +761,78 @@ class TrackedMap {
     }
     return storage;
   }
-  #dirtyStorageFor(key) {
-    const storage = this.#storages.get(key);
+  function dirtyStorageFor(key) {
+    const storage = storages.get(key);
     if (storage) {
       DIRTY_TAG(storage);
     }
   }
-  constructor(existing, options) {
-    // TypeScript doesn't correctly resolve the overloads for calling the `Map`
-    // constructor for the no-value constructor. This resolves that.
-    this.#vals = existing instanceof Map ? new Map(existing.entries()) : new Map(existing);
-    this.#options = options;
-  }
-  get(key) {
-    consumeTag(this.#storageFor(key));
-    return this.#vals.get(key);
-  }
-  has(key) {
-    consumeTag(this.#storageFor(key));
-    return this.#vals.has(key);
-  }
-
-  // **** ALL GETTERS ****
-  entries() {
-    consumeTag(this.#collection);
-    return this.#vals.entries();
-  }
-  getOrInsert(key, defaultValue) {
-    consumeTag(this.#storageFor(key));
-
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore -- older versions of TS don't yet have this method
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call
-    return this.#vals.getOrInsert(key, defaultValue);
-  }
-  getOrInsertComputed(key, creator) {
-    consumeTag(this.#storageFor(key));
-
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore -- older versions of TS don't yet have this method
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call
-    return this.#vals.getOrInsertComputed(key, creator);
-  }
-  keys() {
-    consumeTag(this.#collection);
-    return this.#vals.keys();
-  }
-  values() {
-    consumeTag(this.#collection);
-    return this.#vals.values();
-  }
-  forEach(fn) {
-    consumeTag(this.#collection);
-    this.#vals.forEach(fn);
-  }
-  get size() {
-    consumeTag(this.#collection);
-    return this.#vals.size;
-  }
+  const proxy = new Proxy(target, {
+    get(target, prop, receiver) {
+      if (prop === 'set') {
+        return function (key, value) {
+          const hasExisting = target.has(key);
+          if (hasExisting) {
+            const isUnchanged = equals(target.get(key), value);
+            if (isUnchanged) return proxy;
+          }
+          dirtyStorageFor(key);
+          DIRTY_TAG(collection);
+          target.set(key, value);
+          return proxy;
+        };
+      }
+      if (prop === 'delete') {
+        return function (key) {
+          if (!target.has(key)) return false;
+          dirtyStorageFor(key);
+          DIRTY_TAG(collection);
+          storages.delete(key);
+          return target.delete(key);
+        };
+      }
+      if (prop === 'clear') {
+        return function () {
+          if (target.size === 0) return;
+          storages.forEach(s => DIRTY_TAG(s));
+          storages.clear();
+          DIRTY_TAG(collection);
+          target.clear();
+        };
+      }
+      if (prop === 'get') {
+        return function (key) {
+          consumeTag(storageFor(key));
+          return target.get(key);
+        };
+      }
+      if (prop === 'has') {
+        return function (key) {
+          consumeTag(storageFor(key));
+          return target.has(key);
+        };
+      }
+      if (prop === 'size') {
+        consumeTag(collection);
+        return target.size;
+      }
 
-  /**
-   * When iterating:
-   * - we entangle with the collection (as we iterate over the whole thing
-   * - for each individual item, we entangle with the item as well
-   */
-  [Symbol.iterator]() {
-    let keys = this.keys();
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    let self = this;
-    return {
-      next() {
-        let next = keys.next();
-        let currentKey = next.value;
-        if (next.done) {
-          return {
-            value: [undefined, undefined],
-            done: true
-          };
-        }
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value === 'function') {
+        return function (...args) {
+          consumeTag(collection);
 
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        return {
-          value: [currentKey, self.get(currentKey)],
-          done: false
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+          return value.apply(target, args);
         };
       }
-    };
-  }
-  get [Symbol.toStringTag]() {
-    return this.#vals[Symbol.toStringTag];
-  }
-  set(key, value) {
-    let existing = this.#vals.get(key);
-    if (existing) {
-      let isUnchanged = this.#options.equals(existing, value);
-      if (isUnchanged) {
-        return this;
-      }
-    }
-    this.#dirtyStorageFor(key);
-    if (!existing) {
-      DIRTY_TAG(this.#collection);
-    }
-    this.#vals.set(key, value);
-    return this;
-  }
-  delete(key) {
-    if (!this.#vals.has(key)) return true;
-    this.#dirtyStorageFor(key);
-    DIRTY_TAG(this.#collection);
-    this.#storages.delete(key);
-    return this.#vals.delete(key);
-  }
-  clear() {
-    if (this.#vals.size === 0) return;
-    this.#storages.forEach(s => DIRTY_TAG(s));
-    this.#storages.clear();
-    DIRTY_TAG(this.#collection);
-    this.#vals.clear();
-  }
-}
 
-// So instanceof works
-Object.setPrototypeOf(TrackedMap.prototype, Map.prototype);
-function trackedMap(data, options) {
-  return new TrackedMap(data ?? [], {
-    equals: options?.equals ?? Object.is,
-    description: options?.description
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+      return value;
+    }
   });
+  return proxy;
 }
 
 class TrackedObject {
@@ -975,13 +928,17 @@ function trackedObject(data, options) {
   });
 }
 
-class TrackedSet {
-  #options;
-  #collection = createUpdatableTag();
-  #storages = new Map();
-  #vals;
-  #storageFor(key) {
-    const storages = this.#storages;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// Using a Proxy-based approach so that any new methods added to the Set
+// interface are automatically supported without needing to manually
+// re-implement each one.
+
+function trackedSet(data, options) {
+  const equals = options?.equals ?? Object.is;
+  const target = new Set(data ?? []);
+  const collection = createUpdatableTag();
+  const storages = new Map();
+  function storageFor(key) {
     let storage = storages.get(key);
     if (storage === undefined) {
       storage = createUpdatableTag();
@@ -989,263 +946,238 @@ class TrackedSet {
     }
     return storage;
   }
-  #dirtyStorageFor(key) {
-    const storage = this.#storages.get(key);
+  function dirtyStorageFor(key) {
+    const storage = storages.get(key);
     if (storage) {
       DIRTY_TAG(storage);
     }
   }
-  constructor(existing, options) {
-    this.#vals = new Set(existing);
-    this.#options = options;
-  }
+  const proxy = new Proxy(target, {
+    get(target, prop, receiver) {
+      if (prop === 'add') {
+        return function (value) {
+          if (target.has(value)) {
+            const isUnchanged = equals(value, value);
+            if (isUnchanged) return proxy;
+          } else {
+            DIRTY_TAG(collection);
+          }
+          dirtyStorageFor(value);
+          target.add(value);
+          return proxy;
+        };
+      }
+      if (prop === 'delete') {
+        return function (value) {
+          if (!target.has(value)) return false;
+          dirtyStorageFor(value);
+          DIRTY_TAG(collection);
+          storages.delete(value);
+          return target.delete(value);
+        };
+      }
+      if (prop === 'clear') {
+        return function () {
+          if (target.size === 0) return;
+          storages.forEach(s => DIRTY_TAG(s));
+          DIRTY_TAG(collection);
+          storages.clear();
+          target.clear();
+        };
+      }
+      if (prop === 'has') {
+        return function (value) {
+          consumeTag(storageFor(value));
+          return target.has(value);
+        };
+      }
+      if (prop === 'size') {
+        consumeTag(collection);
+        return target.size;
+      }
 
-  // **** KEY GETTERS ****
-  has(value) {
-    consumeTag(this.#storageFor(value));
-    return this.#vals.has(value);
-  }
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value === 'function') {
+        return function (...args) {
+          consumeTag(collection);
 
-  // **** ALL GETTERS ****
-  entries() {
-    consumeTag(this.#collection);
-    return this.#vals.entries();
-  }
-  keys() {
-    consumeTag(this.#collection);
-    return this.#vals.keys();
-  }
-  values() {
-    consumeTag(this.#collection);
-    return this.#vals.values();
-  }
-  union(other) {
-    consumeTag(this.#collection);
-    return this.#vals.union(other);
-  }
-  intersection(other) {
-    consumeTag(this.#collection);
-    return this.#vals.intersection(other);
-  }
-  difference(other) {
-    consumeTag(this.#collection);
-    return this.#vals.difference(other);
-  }
-  symmetricDifference(other) {
-    consumeTag(this.#collection);
-    return this.#vals.symmetricDifference(other);
-  }
-  isSubsetOf(other) {
-    consumeTag(this.#collection);
-    return this.#vals.isSubsetOf(other);
-  }
-  isSupersetOf(other) {
-    consumeTag(this.#collection);
-    return this.#vals.isSupersetOf(other);
-  }
-  isDisjointFrom(other) {
-    consumeTag(this.#collection);
-    return this.#vals.isDisjointFrom(other);
-  }
-  forEach(fn) {
-    consumeTag(this.#collection);
-    this.#vals.forEach(fn);
-  }
-  get size() {
-    consumeTag(this.#collection);
-    return this.#vals.size;
-  }
-  [Symbol.iterator]() {
-    consumeTag(this.#collection);
-    return this.#vals[Symbol.iterator]();
-  }
-  get [Symbol.toStringTag]() {
-    return this.#vals[Symbol.toStringTag];
-  }
-  add(value) {
-    if (this.#vals.has(value)) {
-      let isUnchanged = this.#options.equals(value, value);
-      if (isUnchanged) return this;
-    } else {
-      DIRTY_TAG(this.#collection);
-    }
-    this.#dirtyStorageFor(value);
-    this.#vals.add(value);
-    return this;
-  }
-  delete(value) {
-    if (!this.#vals.has(value)) return true;
-    this.#dirtyStorageFor(value);
-    DIRTY_TAG(this.#collection);
-    this.#storages.delete(value);
-    return this.#vals.delete(value);
-  }
-
-  // **** ALL SETTERS ****
-  clear() {
-    if (this.#vals.size === 0) return;
-    this.#storages.forEach(s => DIRTY_TAG(s));
-    DIRTY_TAG(this.#collection);
-    this.#storages.clear();
-    this.#vals.clear();
-  }
-}
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+          return value.apply(target, args);
+        };
+      }
 
-// So instanceof works
-Object.setPrototypeOf(TrackedSet.prototype, Set.prototype);
-function trackedSet(data, options) {
-  return new TrackedSet(data ?? [], {
-    equals: options?.equals ?? Object.is,
-    description: options?.description
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+      return value;
+    }
   });
+  return proxy;
 }
 
-class TrackedWeakMap {
-  #options;
-  #storages = new WeakMap();
-  #vals;
-  #storageFor(key) {
-    let storage = this.#storages.get(key);
+// Using a Proxy-based approach so that any new methods added to the WeakMap
+// interface (like getOrInsert, getOrInsertComputed, etc.) are automatically
+// supported without needing to manually re-implement each one.
+
+function trackedWeakMap(data, options) {
+  const equals = options?.equals ?? Object.is;
+  const existing = data ?? [];
+  /**
+   * SAFETY: note that when passing in an existing weak map, we can't
+   *         clone it as it is not iterable and not a supported type of structuredClone
+   */
+  const target = existing instanceof WeakMap ? existing : new WeakMap(existing);
+  const storages = new WeakMap();
+  function storageFor(key) {
+    let storage = storages.get(key);
     if (storage === undefined) {
       storage = createUpdatableTag();
-      this.#storages.set(key, storage);
+      storages.set(key, storage);
     }
     return storage;
   }
-  #dirtyStorageFor(key) {
-    const storage = this.#storages.get(key);
+  function dirtyStorageFor(key) {
+    const storage = storages.get(key);
     if (storage) {
       DIRTY_TAG(storage);
     }
   }
-  constructor(existing, options) {
-    /**
-     * SAFETY: note that wehn passing in an existing weak map, we can't
-     *         clone it as it is not iterable and not a supported type of structuredClone
-     */
-    this.#vals = existing instanceof WeakMap ? existing : new WeakMap(existing);
-    this.#options = options;
-  }
-  get(key) {
-    consumeTag(this.#storageFor(key));
-    return this.#vals.get(key);
-  }
-  has(key) {
-    consumeTag(this.#storageFor(key));
-    return this.#vals.has(key);
-  }
-  set(key, value) {
-    let existing = this.#vals.get(key);
-    if (existing) {
-      let isUnchanged = this.#options.equals(existing, value);
-      if (isUnchanged) {
-        return this;
+  const proxy = new Proxy(target, {
+    get(target, prop, receiver) {
+      if (prop === 'set') {
+        return function (key, value) {
+          const hasExisting = target.has(key);
+          if (hasExisting) {
+            const isUnchanged = equals(target.get(key), value);
+            if (isUnchanged) return proxy;
+          }
+          dirtyStorageFor(key);
+          target.set(key, value);
+          return proxy;
+        };
+      }
+      if (prop === 'delete') {
+        return function (key) {
+          if (!target.has(key)) return false;
+          dirtyStorageFor(key);
+          storages.delete(key);
+          return target.delete(key);
+        };
+      }
+      if (prop === 'get') {
+        return function (key) {
+          consumeTag(storageFor(key));
+          return target.get(key);
+        };
+      }
+      if (prop === 'has') {
+        return function (key) {
+          consumeTag(storageFor(key));
+          return target.has(key);
+        };
       }
-    }
-    this.#dirtyStorageFor(key);
-    this.#vals.set(key, value);
-    return this;
-  }
-  delete(key) {
-    if (!this.#vals.has(key)) return true;
-    this.#dirtyStorageFor(key);
-    this.#storages.delete(key);
-    return this.#vals.delete(key);
-  }
-  get [Symbol.toStringTag]() {
-    return this.#vals[Symbol.toStringTag];
-  }
-}
 
-// So instanceof works
-Object.setPrototypeOf(TrackedWeakMap.prototype, WeakMap.prototype);
-function trackedWeakMap(data, options) {
-  return new TrackedWeakMap(data ?? [], {
-    equals: options?.equals ?? Object.is,
-    description: options?.description
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value === 'function') {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+        return value.bind(target);
+      }
+
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+      return value;
+    }
   });
+  return proxy;
 }
 
-class TrackedWeakSet {
-  #options;
-  #storages = new WeakMap();
-  #vals;
-  #storageFor(key) {
-    let storage = this.#storages.get(key);
+// Using a Proxy-based approach so that any new methods added to the WeakSet
+// interface are automatically supported without needing to manually
+// re-implement each one.
+
+/**
+ * NOTE: we cannot pass a WeakSet because WeakSets are not iterable
+ */
+/**
+ * Creates an instanceof WeakSet from an optional list of entries
+ *
+ */
+function trackedWeakSet(data, options) {
+  const equals = options?.equals ?? Object.is;
+  const target = new WeakSet(data ?? []);
+  const storages = new WeakMap();
+  function storageFor(key) {
+    let storage = storages.get(key);
     if (storage === undefined) {
       storage = createUpdatableTag();
-      this.#storages.set(key, storage);
+      storages.set(key, storage);
     }
     return storage;
   }
-  #dirtyStorageFor(key) {
-    const storage = this.#storages.get(key);
+  function dirtyStorageFor(key) {
+    const storage = storages.get(key);
     if (storage) {
       DIRTY_TAG(storage);
     }
   }
-  constructor(values, options) {
-    this.#options = options;
-    this.#vals = new WeakSet(values);
-  }
-  has(value) {
-    consumeTag(this.#storageFor(value));
-    return this.#vals.has(value);
-  }
-  add(value) {
-    /**
-     * In a WeakSet, there is no `.get()`, but if there was,
-     * we could assume it's the same value as what we passed.
-     *
-     * So for a WeakSet, if we try to add something that already exists
-     * we no-op.
-     *
-     * WeakSet already does this internally for us,
-     * but we want the ability for the reactive behavior to reflect the same behavior.
-     *
-     * i.e.: doing weakSet.add(value) should never dirty with the defaults
-     *       if the `value` is already in the weakSet
-     */
-    if (this.#vals.has(value)) {
-      /**
-       * This looks a little silly, where a always will === b,
-       * but see the note above.
-       */
-      let isUnchanged = this.#options.equals(value, value);
-      if (isUnchanged) return this;
-    }
+  const proxy = new Proxy(target, {
+    get(target, prop, receiver) {
+      if (prop === 'add') {
+        return function (value) {
+          /**
+           * In a WeakSet, there is no `.get()`, but if there was,
+           * we could assume it's the same value as what we passed.
+           *
+           * So for a WeakSet, if we try to add something that already exists
+           * we no-op.
+           *
+           * WeakSet already does this internally for us,
+           * but we want the ability for the reactive behavior to reflect the same behavior.
+           *
+           * i.e.: doing weakSet.add(value) should never dirty with the defaults
+           *       if the `value` is already in the weakSet
+           */
+          if (target.has(value)) {
+            /**
+             * This looks a little silly, where a always will === b,
+             * but see the note above.
+             */
+            const isUnchanged = equals(value, value);
+            if (isUnchanged) return proxy;
+          }
 
-    // Add to vals first to get better error message
-    this.#vals.add(value);
-    this.#dirtyStorageFor(value);
-    return this;
-  }
-  delete(value) {
-    if (!this.#vals.has(value)) return true;
-    this.#dirtyStorageFor(value);
-    this.#storages.delete(value);
-    return this.#vals.delete(value);
-  }
-  get [Symbol.toStringTag]() {
-    return this.#vals[Symbol.toStringTag];
-  }
-}
+          // Add to vals first to get better error message
+          target.add(value);
+          dirtyStorageFor(value);
+          return proxy;
+        };
+      }
+      if (prop === 'delete') {
+        return function (value) {
+          if (!target.has(value)) return false;
+          dirtyStorageFor(value);
+          storages.delete(value);
+          return target.delete(value);
+        };
+      }
+      if (prop === 'has') {
+        return function (value) {
+          consumeTag(storageFor(value));
+          return target.has(value);
+        };
+      }
 
-// So instanceof works
-Object.setPrototypeOf(TrackedWeakSet.prototype, WeakSet.prototype);
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value === 'function') {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+        return value.bind(target);
+      }
 
-/**
- * NOTE: we cannot pass a WeakSet because WeakSets are not iterable
- */
-/**
- * Creates an instanceof WeakSet from an optional list of entries
- *
- */
-function trackedWeakSet(data, options) {
-  return new TrackedWeakSet(data ?? [], {
-    equals: options?.equals ?? Object.is,
-    description: options?.description
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+      return value;
+    }
   });
+  return proxy;
 }
 
 function isObjectLike(u) {
@@ -1256,7 +1188,7 @@ function isObjectLike(u) {
 
 const TRACKED_TAGS = new WeakMap();
 function dirtyTagFor(obj, key, meta) {
-  if (isDevelopingApp() && !isObjectLike(obj)) {
+  if (!isObjectLike(obj)) {
     throw new Error(`BUG: Can't update a tag for a primitive`);
   }
   let tags = meta === undefined ? TRACKED_TAGS.get(obj) : meta;
@@ -1267,7 +1199,7 @@ function dirtyTagFor(obj, key, meta) {
   // Dirty the tag for the specific property if it exists
   let propertyTag = tags.get(key);
   if (propertyTag !== undefined) {
-    if (isDevelopingApp()) {
+    {
       unwrap(debug.assertTagNotConsumed)(propertyTag, obj, key);
     }
     DIRTY_TAG(propertyTag, true);