Grab bag of issue fixes! (#105)

* Add changeset for past PR #82.

* Throw an error when attempting to access RpcTarget instance properties.

This helps people learn why instance properties are not accessible over RPC, whereas returning `undefined` leaves them confused.

Fixes #55

* Implement toString() for RpcStub and RpcPromise.

They just return `[object RpcStub]` and `[object RpcPromise]`, but that's better than the previous `[object Function]` which was confusing.

As suggested in #55.

* Fix type signature of newHttpBatchRpcSession().

An earlier version of the function was designed to have the same signature as `fetch()`, but when I added `RpcSessionOptions` it made more sense to make that the second param... but I only updated the implementation and forgot to update the type.

Fixes #67.

* Support serializing Infinity, -Infinity, and NaN.

Fixes #80

* Polyfill Promise.withResolvers().

This hopefully improves compatibility with old Safari versions and Hermes (React Native).

Unfortunately it didn't seem easy to extend the tests to cover React Native. There is a vitest-react-native package, but it looks little-used and unmaintained, so I didn't want to install it.

Might help with #91, though I won't declare that one "fixed" until we actually have tests proving it.

* Document missing expression types in protocol.md.

Fixes #48

Author: kentonv

.changeset/fast-rules-thank.md

@@ -0,0 +1,5 @@
+---
+"capnweb": minor
+---
+
+Fixed incompatibility with bundlers that don't support top-level await. The top-level await was used for a conditional import; it has been replaced with an approach based on "exports" in package.json instead.

.changeset/frank-drinks-sleep.md

@@ -0,0 +1,5 @@
+---
+"capnweb": patch
+---
+
+Attempting to remotely access an instance property of an RpcTarget will now throw an exception rather than returning `undefined`, in order to help people understand what went wrong.

.changeset/salty-trams-stop.md

@@ -0,0 +1,5 @@
+---
+"capnweb": minor
+---
+
+Support serializing Infinity, -Infinity, and NaN.

.changeset/six-banks-pull.md

@@ -0,0 +1,5 @@
+---
+"capnweb": patch
+---
+
+Polyfilled Promise.withResolvers() to improve compatibility with old Safari versions and Hermes (React Native).

__tests__/index.test.ts

@@ -29,6 +29,10 @@ let SERIALIZE_TEST_CASES: Record<string, unknown> = {
   '["error","Error","the message"]': new Error("the message"),
   '["error","TypeError","the message"]': new TypeError("the message"),
   '["error","RangeError","the message"]': new RangeError("the message"),
+
+  '["inf"]': Infinity,
+  '["-inf"]': -Infinity,
+  '["nan"]': NaN,
 };
 
 class NotSerializable {
@@ -305,8 +309,16 @@ describe("local stub", () => {
 
     expect(await stub.prototypeProp).toBe("prototype");
     expect(await stub.prototypeMethod()).toBe("method");
-    expect(await (stub as any).instanceProp).toBe(undefined);
-    expect(await (stub as any).dynamicProp).toBe(undefined);
+    await expect(() => (stub as any).instanceProp).rejects.toThrow(new TypeError(
+        "Attempted to access property 'instanceProp', which is an instance property of the " +
+        "RpcTarget. To avoid leaking private internals, instance properties cannot be accessed " +
+        "over RPC. If you want to make this property available over RPC, define it as a method " +
+        "or getter on the class, instead of an instance property."));
+    await expect(() => (stub as any).dynamicProp).rejects.toThrow(new TypeError(
+        "Attempted to access property 'dynamicProp', which is an instance property of the " +
+        "RpcTarget. To avoid leaking private internals, instance properties cannot be accessed " +
+        "over RPC. If you want to make this property available over RPC, define it as a method " +
+        "or getter on the class, instead of an instance property."));
   });
 
   it("does not expose private methods starting with #", async () => {
@@ -387,6 +399,13 @@ describe("local stub", () => {
           [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144]],
     ]);
   });
+
+  it("overrides toString() to at least specify the type", async () => {
+    let stub = new RpcStub(new TestTarget());
+    expect(stub.toString()).toBe("[object RpcStub]");
+    let promise = stub.square(3);
+    expect(promise.toString()).toBe("[object RpcPromise]");
+  });
 });
 
 describe("stub disposal", () => {

protocol.md

@@ -130,6 +130,22 @@ This expression will evaluate to the following object:
 }
 ```
 
+`["undefined"]`
+
+The literal value `undefined`.
+
+`["inf"]`, `["-inf"]`, `["nan"]`
+
+The values Infinity, -Infinity, and NaN.
+
+`["bytes", base64]`
+
+A `Uint8Array`, represented as a base64-encoded string.
+
+`["bigint", decimal]`
+
+A bigint value, represented as a decimal string.
+
 `["date", number]`
 
 A JavaScript `Date` value. The number represents milliseconds since the Unix epoch.

src/core.ts

@@ -13,6 +13,20 @@ if (!Symbol.asyncDispose) {
   (Symbol as any).asyncDispose = Symbol.for('asyncDispose');
 }
 
+// Polyfill Promise.withResolvers() for old Safari versions (ugh), Hermes (React Native), and
+// maybe others.
+if (!Promise.withResolvers) {
+  Promise.withResolvers = function<T>(): PromiseWithResolvers<T> {
+    let resolve: (value: T | PromiseLike<T>) => void;
+    let reject: (reason?: any) => void;
+    const promise = new Promise<T>((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    return { promise, resolve: resolve!, reject: reject! };
+  };
+}
+
 let workersModule: any = (globalThis as any)[WORKERS_MODULE_SYMBOL];
 
 export interface RpcTarget {
@@ -426,6 +440,10 @@ export class RpcStub extends RpcTarget {
     let {hook, pathIfPromise} = this[RAW_STUB];
     return mapImpl.sendMap(hook, pathIfPromise || [], func);
   }
+
+  toString() {
+    return "[object RpcStub]";
+  }
 }
 
 export class RpcPromise extends RpcStub {
@@ -447,6 +465,10 @@ export class RpcPromise extends RpcStub {
   finally(onfinally?: (() => void) | undefined | null): Promise<unknown> {
     return pullPromise(this).finally(...arguments);
   }
+
+  toString() {
+    return "[object RpcPromise]";
+  }
 }
 
 // Given a stub (still wrapped in a Proxy), extract the underlying `StubHook`.
@@ -1224,7 +1246,15 @@ function followPath(value: unknown, parent: object | undefined,
       case "rpc-thenable": {
         // Must be prototype property, and must NOT be inherited from `Object`.
         if (Object.hasOwn(<object>value, part)) {
-          value = undefined;
+          // We throw an error in this case, rather than return undefined, because otherwise
+          // people tend to get confused about this. If you don't want it to be possible to
+          // probe the existence of your instance properties, make them properly private (prefix
+          // with #).
+          throw new TypeError(
+              `Attempted to access property '${part}', which is an instance property of the ` +
+              `RpcTarget. To avoid leaking private internals, instance properties cannot be ` +
+              `accessed over RPC. If you want to make this property available over RPC, define ` +
+              `it as a method or getter on the class, instead of an instance property.`);
         } else {
           value = (<any>value)[part];
         }

src/index.ts

@@ -118,7 +118,7 @@ export let newWebSocketRpcSession:<T extends Serializable<T> = Empty>
  * (it will always be set to POST) and the body (which the RPC system will fill in).
  */
 export let newHttpBatchRpcSession:<T extends Serializable<T>>
-    (urlOrRequest: string | Request, init?: RequestInit) => RpcStub<T> =
+    (urlOrRequest: string | Request, options?: RpcSessionOptions) => RpcStub<T> =
     <any>newHttpBatchRpcSessionImpl;
 
 /**

src/serialize.ts

@@ -114,8 +114,18 @@ export class Devaluator {
       }
 
       case "primitive":
-        // Supported directly by JSON.
-        return value;
+        if (typeof value === "number" && !isFinite(value)) {
+          if (value === Infinity) {
+            return ["inf"];
+          } else if (value === -Infinity) {
+            return ["-inf"];
+          } else {
+            return ["nan"];
+          }
+        } else {
+          // Supported directly by JSON.
+          return value;
+        }
 
       case "object": {
         let object = <Record<string, unknown>>value;
@@ -347,6 +357,12 @@ export class Evaluator {
             return undefined;
           }
           break;
+        case "inf":
+          return Infinity;
+        case "-inf":
+          return -Infinity;
+        case "nan":
+          return NaN;
 
         case "import":
         case "pipeline": {