A colleague wraps existing objects in a JavaScript Proxy expecting a drop-in replacement. Which kinds of objects stop working through the proxy, and why?

## Where the transparency ends For an ordinary object whose state lives in ordinary properties, an empty-handler proxy is indistinguishable from the target: reads, writes, deletes and key listing all forward. The illusion breaks in exactly two places — state that is keyed to the object itself rather than stored as a property, and code that compares object identity. ## Private fields ```js class Counter { #n = 0; inc() { return ++this.#n; } } const p = new Proxy(new Counter(), {}); p.inc(); // TypeError: Cannot read private member #n from an object whose class did not declare it ``` Private fields are not properties. They are installed on the instance at construction and can only be found on that exact object. `p.inc` resolves the method through the prototype chain normally, but the call sets `this` to the proxy, and the proxy was never constructed by `Counter`, so it carries no `#n`. No trap can intercept this — private-field access is not a property operation and has no trap. ## Built-ins with internal slots The same shape applies to most built-ins, because their real data lives in internal slots rather than properties: ```js const m = new Proxy(new Map([['k', 1]]), {}); m.get('k'); // TypeError: incompatible receiver const d = new Proxy(new Date(), {}); d.getTime(); // TypeError ``` `Map`, `Set`, `WeakMap`, `Date`, typed arrays, `ArrayBuffer`, promises and DOM nodes all behave this way; a DOM method called on a proxy typically reports an "Illegal invocation". Plain objects, arrays and functions are the well-behaved cases: arrays keep their exotic length behaviour through a proxy, and `typeof proxy` is `"function"` when the target is callable, so a proxied function is still callable and constructible. ## Identity The proxy is a distinct object, and nothing makes it compare equal to the target: - `proxy === target` is `false`, always. - A `Map` or `WeakMap` entry stored under the target is not found when you look it up with the proxy, and vice versa. Caches, dedup sets and registries keyed by object silently miss. - A `Set` given both will hold two entries. - `structuredClone(proxy)` and `postMessage(proxy)` throw a `DataCloneError`; structured serialization only understands recognised object kinds, and a proxy is not one. This is why reactive libraries expose an unwrap helper — Vue calls it `toRaw` — that you must call before sending state to a worker or IndexedDB. Two checks deliberately do see through: `Array.isArray` reports on the target's kind, and `instanceof` works because the default `getPrototypeOf` trap forwards to the target's prototype. `JSON.stringify` also works, because it only performs ordinary property operations, which the traps handle. ## The usual patch, and its price The standard workaround is to bind methods to the real target in the `get` trap: ```js const safe = (obj) => new Proxy(obj, { get(t, key, receiver) { const value = Reflect.get(t, key, receiver); return typeof value === 'function' ? value.bind(t) : value; } }); safe(new Map([['k', 1]])).get('k'); // 1 ``` This works because the method now runs with the real instance as `this`, so private fields and internal slots resolve. But you have traded transparency for it: every call made through those bound methods operates on the target directly, so a `Map`'s writes never touch your traps, `this` inside the object refers to the unwrapped instance so its own self-calls escape, and you have introduced a fresh function object on each read unless you cache the bindings. ## What to do instead Decide up front what your proxy is allowed to wrap. Reactive layers typically refuse anything they cannot handle — class instances, DOM nodes, typed arrays, dates — and either pass them through raw or instrument collection types explicitly by replacing their methods rather than relying on default forwarding. Keep the raw reference reachable through a documented unwrap function for identity-sensitive boundaries: serialization, worker transfer, object-keyed caches, and equality checks. And never let both the raw object and its proxy circulate freely in the same code path, because then equality becomes a coin flip depending on which reference a caller happens to hold.