fix(cloudflare): use correct Proxy receiver in instrumentDurableObjectStorage

The storage Proxy's get trap passed `receiver` (the proxy itself) to
`Reflect.get`, causing native workerd getters like `storage.sql` to
throw 'Illegal invocation' due to failed internal slot / brand checks.

Use `target` as the receiver so native getters execute with the correct
`this` binding.

Author: dmmulroy

packages/cloudflare/src/instrumentations/instrumentDurableObjectStorage.ts

@@ -16,8 +16,13 @@ type StorageMethod = (typeof STORAGE_METHODS_TO_INSTRUMENT)[number];
  */
 export function instrumentDurableObjectStorage(storage: DurableObjectStorage): DurableObjectStorage {
   return new Proxy(storage, {
-    get(target, prop, receiver) {
-      const original = Reflect.get(target, prop, receiver);
+    get(target, prop, _receiver) {
+      // Use `target` as the receiver instead of the proxy (`_receiver`).
+      // Native workerd getters (e.g., `storage.sql`) validate `this` via
+      // internal slots. Passing the proxy as receiver breaks that check,
+      // causing "Illegal invocation: function called with incorrect `this`
+      // reference" errors.
+      const original = Reflect.get(target, prop, target);
 
       if (typeof original !== 'function') {
         return original;

packages/cloudflare/test/instrumentDurableObjectStorage.test.ts

@@ -182,6 +182,41 @@ describe('instrumentDurableObjectStorage', () => {
     });
   });
 
+  describe('native getter preservation (sql)', () => {
+    it('preserves native getter `this` binding for sql accessor', () => {
+      // Simulates workerd's native DurableObjectStorage where `sql` is a
+      // getter that validates `this` via internal slots (brand check).
+      // Using a private field as the closest JS equivalent of a native
+      // internal slot check — accessing `#sqlInstance` on the wrong `this`
+      // throws a TypeError, just like workerd's "Illegal invocation".
+      const storage = createBrandCheckedStorage();
+      const instrumented = instrumentDurableObjectStorage(storage as any);
+
+      // Before fix: this threw "Cannot read private member #sqlInstance
+      // from an object whose class did not declare it" (equivalent of
+      // workerd's "Illegal invocation: function called with incorrect
+      // `this` reference")
+      expect(() => (instrumented as any).sql).not.toThrow();
+      expect((instrumented as any).sql).toBeDefined();
+      expect((instrumented as any).sql.exec).toBeDefined();
+    });
+
+    it('sql.exec works through the instrumented proxy', () => {
+      const storage = createBrandCheckedStorage();
+      const instrumented = instrumentDurableObjectStorage(storage as any);
+
+      const result = (instrumented as any).sql.exec('SELECT 1');
+      expect(result).toEqual({ query: 'SELECT 1' });
+    });
+
+    it('non-instrumented methods preserve native `this` binding', () => {
+      const storage = createBrandCheckedStorage();
+      const instrumented = instrumentDurableObjectStorage(storage as any);
+
+      expect(() => (instrumented as any).getAlarm()).not.toThrow();
+    });
+  });
+
   describe('error handling', () => {
     it('propagates errors from storage operations', async () => {
       const mockStorage = createMockStorage();
@@ -210,3 +245,50 @@ function createMockStorage(): any {
     },
   };
 }
+
+/**
+ * Creates a storage mock that uses a class with private fields to simulate
+ * workerd's native brand-checked getters. Private field access throws a
+ * TypeError when `this` is not the original instance, mimicking the
+ * "Illegal invocation" error from workerd native accessors.
+ */
+class BrandCheckedStorage {
+  #sqlInstance = { exec: (query: string) => ({ query }) };
+  #data = new Map<string, unknown>();
+
+  get sql() {
+    // Accessing #sqlInstance implicitly checks that `this` is a real
+    // BrandCheckedStorage instance. If `this` is a Proxy with wrong
+    // receiver, this throws TypeError.
+    return this.#sqlInstance;
+  }
+
+  async get(key: string) {
+    return this.#data.get(key);
+  }
+  async put(key: string, value: unknown) {
+    this.#data.set(key, value);
+  }
+  async delete(key: string) {
+    return this.#data.delete(key);
+  }
+  async list() {
+    return new Map(this.#data);
+  }
+  async getAlarm() {
+    return null;
+  }
+  async setAlarm(_scheduledTime: number) {}
+  async deleteAlarm() {}
+  async deleteAll() {
+    this.#data.clear();
+  }
+  async sync() {}
+  async transaction(cb: (txn: unknown) => unknown) {
+    return cb(this);
+  }
+}
+
+function createBrandCheckedStorage() {
+  return new BrandCheckedStorage();
+}